Open Ticket v4.0.4

Dev v4.0.4
2025-05-01 14:10:55 +02:00 · 2025-05-01 14:05:56 +02:00 · 2025-05-01 14:05:06 +02:00 · 2025-05-01 13:56:38 +02:00 · 2025-04-28 18:27:48 +02:00 · 2025-04-28 18:22:54 +02:00
166 changed files with 9609 additions and 5589 deletions
@@ -0,0 +1,328 @@
+//@ts-check
+const fs = require("fs")
+
+/*////// OT DOCS GENERATOR ////////
+What does this file do?:
+Well, this file will parse the result returned from typedoc (the documentation generator).
+The resulting file will then be used in the OT Docs markdown generator to generate the Open Ticket API Reference.
+
+In short:
+This file generates the documentation for Open Ticket :)
+
+Contributing:
+If you want to contribute to the Open Ticket Docs, please run the following command:
+
+> npm run docs
+
+This will give you a "result.json" file which can then be used in the OT Docs.
+Further instructions can be found there.
+/////////////////////////////////*/
+
+if (!fs.existsSync(".docs/typedoc-result.json")){
+    console.log("Unable to generate documentation! Run typedoc first!")
+    process.exit(1)
+}
+const result = JSON.parse(fs.readFileSync(".docs/typedoc-result.json").toString())
+const availableElements = []
+const skipElementNames = [
+    "#opendiscord-types"
+]
+
+const handleFunction = (memberType) => {
+    if (!memberType || !memberType.signatures || !Array.isArray(memberType.signatures)) return {type:"unknown"}
+    
+    //try to get signature
+    let signature = memberType.signatures.find((s) => !s.typeParameters)
+    if (!signature) signature = memberType.signatures[0]
+    if (!signature) return {type:"unknown"}
+
+    //try to get comment
+    let comment = signature.comment
+    if (!comment) comment = memberType.signatures.find((s) => s.comment)?.comment
+    if (!comment) comment = null
+
+    const signatureInherited = signature.flags.isInherited ? true : false
+    const signatureComment = comment ? comment.summary?.map((c) => c.text).join("") : null
+    const signatureParameters = signature.parameters?.map((p) => {
+        return {name:p.name,details:handleType(p.type)}
+    }) ?? []
+    const signatureReturns = handleType(signature.type)
+
+    return {type:"function",inherited:signatureInherited,comment:signatureComment,parameters:signatureParameters,returns:signatureReturns}
+}
+
+const handleObject = (memberType) => {
+    if (!memberType || !memberType.children || !Array.isArray(memberType.children)) return {type:"unknown"}
+    const propertyIds = memberType.groups?.find((g) => g.title == "Properties")?.children ?? []
+    const methodIds = memberType.groups?.find((g) => g.title == "Methods")?.children ?? []
+
+    const objectChildren = []
+    for (const member of (memberType.children ?? [])){
+        const memberName = member.name
+        const memberType = propertyIds.includes(member.id) ? "property" : methodIds.includes(member.id) ? "method" : "other"
+        let memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+        
+        const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+        let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+        let memberDetails = null
+        if (memberType == "property"){
+            //INTERFACE => PROPERTY
+            memberDetails = handleType(member.type)
+        }else if (memberType == "method"){
+            //INTERFACE => METHOD
+            memberDetails = handleFunction(member)
+            memberComment = memberDetails.comment
+        }
+
+        objectChildren.push({
+            type:memberType,
+            name:memberName,
+            comment:memberComment,
+            source:memberSource,
+            details:memberDetails
+        })
+    }
+    return {type:"object",children:objectChildren}
+}
+
+const handleType = (memberType) => {
+    if (!memberType || !memberType.type) return {type:"unknown"}
+    else if (memberType.type == "intrinsic") return {type:"primitive",name:memberType.name}
+    else if (memberType.type == "array") return {type:"array",child:handleType(memberType.elementType)}
+    else if (memberType.type == "union") return {type:"union",children:memberType.types.map((t) => handleType(t))}
+    else if (memberType.type == "intersection") return {type:"intersection",children:memberType.types.map((t) => handleType(t))}
+    else if (memberType.type == "reference"){
+        const referenceTypeArguments = (memberType.typeArguments) ? memberType.typeArguments.map((ta) => handleType(ta)) : null
+        let referenceType = availableElements.find((el) => el.name == memberType.name)?.type ?? null
+
+        if (referenceType){
+            //member is known type (from Open Ticket)
+            return {type:"reference",name:memberType.name,target:referenceType,typeArguments:referenceTypeArguments}
+        }else if (memberType.package){
+            //member is type from node.js or another package
+            if (memberType.package == "typescript") return {type:"internal",name:memberType.name,typeArguments:referenceTypeArguments}
+            if (memberType.package == "open-ticket" && memberType.refersToTypeParameter) return {type:"typeParam",name:memberType.name,typeArguments:referenceTypeArguments}
+            else return {type:"external",package:memberType.package,name:memberType.name,typeArguments:referenceTypeArguments}
+        }else return {type:"unknown"}
+    }
+    else if (memberType.type == "literal") return {type:"literal",name:(typeof memberType.value == "string") ? JSON.stringify(memberType.value) : String(memberType.value)}
+    else if (memberType.type == "typeOperator"){
+        if (memberType.operator == "keyof") return {type:"keyof",child:handleType(memberType.target)}
+        else if (memberType.operator == "readonly") return {type:"readonly",child:handleType(memberType.target)}
+        else if (memberType.operator == "unique") return {type:"unique",child:handleType(memberType.target)}
+    }
+    else if (memberType.type == "conditional") return {type:"conditional",checker:handleType(memberType.checkType),extends:handleType(memberType.extendsType),trueValue:handleType(memberType.trueType),falseValue:handleType(memberType.falseType)}
+    else if (memberType.type == "indexedAccess") return {type:"index",index:handleType(memberType.indexType),object:handleType(memberType.objectType)}
+    else if (memberType.type == "mapped") return {type:"mapped",parameterName:memberType.parameter,parameter:handleType(memberType.parameterType),template:handleType(memberType.templateType)}
+    else if (memberType.type == "optional") return {type:"optional",child:handleType(memberType.elementType)}
+    else if (memberType.type == "predicate") return {type:"predicate",name:memberType.name,target:handleType(memberType.targetType)}
+    else if (memberType.type == "query") return {type:"query",target:handleType(memberType.queryType)}
+    else if (memberType.type == "rest") return {type:"rest",child:handleType(memberType.elementType)}
+    else if (memberType.type == "tuple") return {type:"tuple",children:memberType.elements.map((t) => handleType(t))}
+    else if (memberType.type == "templateLiteral") return {type:"template",head:memberType.head,tails:memberType.tail.map((t) => {
+        return {element:handleType(t[0]),text:t[1]}
+    })}
+    else if (memberType.type == "reflection" && memberType.declaration && memberType.declaration.signatures && memberType.declaration.signatures[0]){
+        return handleFunction(memberType.declaration)
+    }
+    else if (memberType.type == "reflection"){
+        return handleObject(memberType.declaration)
+    }
+    else return {type:"unknown"}
+}
+
+for (const file of result.children){
+    const classIds = file.groups?.find((g) => g.title == "Classes")?.children ?? []
+    const interfaceIds = file.groups?.find((g) => g.title == "Interfaces")?.children ?? []
+    const typeIds = file.groups?.find((g) => g.title == "Type Aliases")?.children ?? []
+    const enumIds = file.groups?.find((g) => g.title == "Enumerations")?.children ?? []
+    const varIds = file.groups?.find((g) => g.title == "Variables")?.children ?? []
+    const funcIds = file.groups?.find((g) => g.title == "Functions")?.children ?? []
+
+    for (const declaration of file.children){
+        const declarationName = declaration.name
+        const declarationType = classIds.includes(declaration.id) ? "class" : interfaceIds.includes(declaration.id) ? "interface" : typeIds.includes(declaration.id) ? "type" : enumIds.includes(declaration.id) ? "enum" : varIds.includes(declaration.id) ? "variable" : funcIds.includes(declaration.id) ? "function" : "other"
+        availableElements.push({name:declarationName,type:declarationType})
+    }
+}
+
+const exported = []
+for (const file of result.children){
+    const classIds = file.groups?.find((g) => g.title == "Classes")?.children ?? []
+    const interfaceIds = file.groups?.find((g) => g.title == "Interfaces")?.children ?? []
+    const typeIds = file.groups?.find((g) => g.title == "Type Aliases")?.children ?? []
+    const enumIds = file.groups?.find((g) => g.title == "Enumerations")?.children ?? []
+    const varIds = file.groups?.find((g) => g.title == "Variables")?.children ?? []
+    const funcIds = file.groups?.find((g) => g.title == "Functions")?.children ?? []
+
+    for (const declaration of (file.children ?? [])){
+        const declarationName = declaration.name
+        if (skipElementNames.includes(declarationName)) continue
+
+        const declarationType = classIds.includes(declaration.id) ? "class" : interfaceIds.includes(declaration.id) ? "interface" : typeIds.includes(declaration.id) ? "type" : enumIds.includes(declaration.id) ? "enum" : varIds.includes(declaration.id) ? "variable" : funcIds.includes(declaration.id) ? "function" : "other"
+        const declarationTypeParams = (declaration.typeParameters) ? declaration.typeParameters.map((tp) => {
+            return {name:tp.name,type:handleType(tp.type)}
+        }) : null
+        const declarationComment = declaration.comment?.summary?.map((c) => c.text).join("") ?? null
+        const declarationConstant = declaration.flags.isConst ? true : false
+        
+        const rawDeclarationSource = declaration.sources ? (declaration.sources[0] ?? null) : null
+        const declarationSource = rawDeclarationSource ? rawDeclarationSource.fileName+":"+rawDeclarationSource.line+":"+rawDeclarationSource.character : null
+
+        const declarationChildren = []
+        if (declarationType == "class"){
+            //CLASS
+            const constructorIds = declaration.groups?.find((g) => g.title == "Constructors")?.children ?? []
+            const propertyIds = declaration.groups?.find((g) => g.title == "Properties")?.children ?? []
+            const methodIds = declaration.groups?.find((g) => g.title == "Methods")?.children ?? []
+
+            for (const member of (declaration.children ?? [])){
+                const memberName = member.name
+                const memberType = constructorIds.includes(member.id) ? "constructor" : propertyIds.includes(member.id) ? "property" : methodIds.includes(member.id) ? "method" : "other"
+                let memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+                
+                const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+                let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+                const memberInherited = member.flags.isInherited ? true : false
+                const memberStatic = member.flags.isStatic ? true : false
+                const memberProtected = member.flags.isProtected ? true : false
+                const memberOptional = member.flags.isOptional ? true : false
+                const memberReadonly = member.flags.isReadonly ? true : false
+
+                let memberDetails = null
+                if (memberType == "property"){
+                    //CLASS => PROPERTY
+                    memberDetails = handleType(member.type)
+
+                }else if (memberType == "method"){
+                    //CLASS => METHOD
+                    memberDetails = handleFunction(member)
+                    memberComment = memberDetails.comment
+                    
+                }else if (memberType == "constructor"){
+                    //CLASS => CONSTRUCTOR
+                    memberDetails = handleFunction(member)
+                    memberComment = memberDetails.comment
+                }
+
+                declarationChildren.push({
+                    type:memberType,
+                    name:memberName,
+                    comment:memberComment,
+                    source:memberSource,
+                    details:memberDetails,
+                    inherited:memberInherited,
+                    static:memberStatic,
+                    protected:memberProtected,
+                    optional:memberOptional,
+                    readonly:memberReadonly
+                })
+            }
+        }else if (declarationType == "interface"){
+            //INTERFACE
+            const propertyIds = declaration.groups?.find((g) => g.title == "Properties")?.children ?? []
+            const methodIds = declaration.groups?.find((g) => g.title == "Methods")?.children ?? []
+
+            for (const member of (declaration.children ?? [])){
+                const memberName = member.name
+                const memberType = propertyIds.includes(member.id) ? "property" : methodIds.includes(member.id) ? "method" : "other"
+                let memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+                
+                const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+                let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+                const memberInherited = member.flags.isInherited ? true : false
+                const memberStatic = member.flags.isStatic ? true : false
+                const memberProtected = member.flags.isProtected ? true : false
+                const memberOptional = member.flags.isOptional ? true : false
+                const memberReadonly = member.flags.isReadonly ? true : false
+
+                let memberDetails = null
+                if (memberType == "property"){
+                    //INTERFACE => PROPERTY
+                    memberDetails = handleType(member.type)
+                }else if (memberType == "method"){
+                    //INTERFACE => METHOD
+                    memberDetails = handleFunction(member)
+                    memberComment = memberDetails.comment
+                }
+
+                declarationChildren.push({
+                    type:memberType,
+                    name:memberName,
+                    comment:memberComment,
+                    source:memberSource,
+                    details:memberDetails,
+                    inherited:memberInherited,
+                    static:memberStatic,
+                    protected:memberProtected,
+                    optional:memberOptional,
+                    readonly:memberReadonly
+                })
+            }
+        }else if (declarationType == "type"){
+            //TYPE
+            declarationChildren.push(handleType(declaration.type))
+        }else if (declarationType == "enum"){
+            //ENUM
+            const enumerableIds = declaration.groups?.find((g) => g.title == "Enumeration Members")?.children ?? []
+
+            for (const member of (declaration.children ?? [])){
+                const memberName = member.name
+                const memberType = enumerableIds.includes(member.id) ? "enumerable" : "other"
+                const memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+                
+                const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+                let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+                let memberDetails = null
+                if (memberType == "enumerable"){
+                    //ENUM => ENUMERABLE
+                    memberDetails = handleType(member.type)
+                }
+
+                const memberInherited = member.flags.isInherited ? true : false
+                const memberStatic = member.flags.isStatic ? true : false
+                const memberProtected = member.flags.isProtected ? true : false
+                const memberOptional = member.flags.isOptional ? true : false
+                const memberReadonly = member.flags.isReadonly ? true : false
+
+                declarationChildren.push({
+                    type:memberType,
+                    name:memberName,
+                    comment:memberComment,
+                    source:memberSource,
+                    details:memberDetails,
+                    inherited:memberInherited,
+                    static:memberStatic,
+                    protected:memberProtected,
+                    optional:memberOptional,
+                    readonly:memberReadonly
+                })
+            }
+        }else if (declarationType == "variable"){
+            //VARIABLE
+            declarationChildren.push(handleType(declaration.type))
+
+        }else if (declarationType == "function"){
+            //FUNCTION
+            declarationChildren.push(handleFunction(declaration))
+            
+        }
+
+        exported.push({
+            type:declarationType,
+            name:declarationName,
+            comment:declarationComment,
+            constant:declarationConstant,
+            source:declarationSource,
+            children:declarationChildren,
+            typeParams:declarationTypeParams
+        })
+    }
+}
+
+fs.writeFileSync(".docs/result.json",JSON.stringify(exported,null,"\t"))
+fs.rmSync(".docs/typedoc-result.json")
@@ -0,0 +1,13 @@
+{
+    "$schema": "https://typedoc.org/schema.json",
+    "entryPoints": [
+        "../src/core/api/modules/",
+        "../src/core/api/defaults/",
+        "../src/core/api/openticket/",
+        "../src/core/api/main.ts",
+        "../src/core/startup/init.ts",
+    ],
+    "entryPointStrategy": "expand",
+    "json": "./typedoc-result.json",
+    "basePath": "../"
+}
@@ -0,0 +1,50 @@
+# Pterodactyl Eggs
+<img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="500px">
+
+[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)
+[![version](https://img.shields.io/badge/version-4.0.4-brightgreen.svg?style=flat-square)](https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.4)
+[![Sponsor DJj123dj](https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors)](https://github.com/sponsors/DJj123dj)
+[![Open Ticket supports Pterodactyl Eggs!](https://img.shields.io/badge/pterodactyl-supported-10539F?style=flat-square&logo=pterodactyl)](.eggs/README.md)
+
+
+Hi there! Open Ticket provides **official eggs** for the Pterodactyl & Pelican panels!<br>
+There are different eggs for different versions of Open Ticket.
+Please choose the one that fits your needs the most.
+
+If you encounter any issues while installing these eggs, please head to our [**discord server**](https://discord.dj-dj.be) for further assistance!
+
+### Requirements
+It's recommended to provide at least `1GB` of **Memory/RAM** and `5GB` of **disk space** for Open Ticket to work correctly.
+
+### Egg Variants
+[**`openticket-egg-main.json` (Recommended)**](openticket-egg-main.json)
+- This egg will use the `main` branch of Open Ticket.
+
+[**`openticket-egg-v4.0.4.json`**](openticket-egg-v4.0.4.json)
+- This egg will always use Open Ticket `v4.0.4`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v4.0.3.json`**](openticket-egg-v4.0.3.json)
+- This egg will always use Open Ticket `v4.0.3`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v4.0.2.json`**](openticket-egg-v4.0.2.json)
+- This egg will always use Open Ticket `v4.0.2`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v4.0.1.json`**](openticket-egg-v4.0.1.json)
+- This egg will always use Open Ticket `v4.0.1`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v4.0.0.json`**](openticket-egg-v4.0.0.json)
+- This egg will always use Open Ticket `v4.0.0`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v3.5.9.json`**](openticket-egg-v3.5.9.json)
+- This egg will always use Open Ticket `v3.5.9`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-dev.json` (Not Recommended)**](openticket-egg-dev.json)
+- This egg will use the `dev` branch of Open Ticket.
+
+---
+<img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="170px">
+
+**Pterodactyl Eggs**<br>
+[changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be)<br>
+
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:21+01:00",
+    "name": "Open Ticket (Experimental)",
+    "author": "support@dj-dj.be",
+    "description": "This is the experimental Pterodactyl egg for Open Ticket, the most advanced & customisable discord ticket bot that you will ever find! DO NOT USE IN PRODUCTION!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (dev)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"dev\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:20+01:00",
+    "name": "Open Ticket (Latest)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (main)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"main\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:19+01:00",
+    "name": "Open Ticket (v3.5.9)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v3.5.9, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v3.5.9)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v3.5.9\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.0)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.0, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.0)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.0\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.1)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.1, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.1)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.1\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.2)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.2, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.2)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.2\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.3)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.3, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.3)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.3\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.4)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.4, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.4)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.4\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}
@@ -6,14 +6,12 @@ You can choose which type of tutorial you want to make. You can create a quick s
 You are not required to talk in the video, but make sure it has some kind of subtitles instead.

 ### 📄 Requirements
- 📌 At least 2k subscribers!
- 📌 A little bit of channel activity! *(minimum 2 uploads/month)*
- 📌 Video length of at least 3 minutes!
- 📌 Provide a clear link to the Open Ticket repository!
- 📌 Recommended language is English!
- 📌 Recommended platform is YouTube!
- 📌 Must be for the latest version of Open Ticket!
- 📌 **(OPTIONAL)** Speech in the video *(AI is allowed)*
+- 📌 Video length of at least 2 minutes.
+- 📌 Provide a link to the Open Ticket repository in the description of the video.
+- 📌 Please use the latest version of Open Ticket available at the time of making the video.
+- 📌 **(Optional)** Recommended language is English.
+- 📌 **(Optional)** Recommended platform is YouTube!
+- 📌 **(Optional)** Speech in the video *(AI is allowed)*


 ### 🎁 Rewards
@@ -1,7 +1,7 @@
 # Contributing Guidelines
 <img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="500px">

-[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.0-brightgreen.svg?style=flat-square)](https://github.com/DJj123dj/open-ticket/releases/tag/v4.0.0)
+[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.4-brightgreen.svg?style=flat-square)](https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.4)  [![Sponsor DJj123dj](https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors)](https://github.com/sponsors/DJj123dj)

 These are the Contributing Guidelines of Open Ticket!<br>
 Here you can find everything you need to know about contributing to Open Ticket.<br>
@@ -36,7 +36,7 @@ Metadata can be found in the `_TRANSLATION` variable.
 #### Step 4: Uploading
 1. When adding a new language, please mention @DJj123dj. He will add the code required for the language to work.
 2. There are currently 3 ways of uploading translations:
-   -  Create a pull request to the [__`dev` branch!__](https://github.com/DJj123dj/open-ticket/tree/dev)
+   -  Create a pull request to the [__`dev` branch!__](https://github.com/open-discord-bots/open-ticket/tree/dev)
   -  Create a ticket in our [discord server](https://discord.dj-dj.be)!
   -  Send a DM to @DJj123dj on discord!
 3. Now you'll need to wait until the next Open Ticket version for it to be added.
@@ -89,4 +89,4 @@ you are **REQUIRED to send the bug privately via one of the following methods:**
 **Contributing Guidelines**<br>
 [changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be)<br>

-© 2024 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
@@ -1,7 +1,7 @@
 # Security Policy
 <img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="500px">

-[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.0-brightgreen.svg?style=flat-square)](https://github.com/DJj123dj/open-ticket/releases/tag/v4.0.0)  [![Sponsor DJj123dj](https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors)](https://github.com/sponsors/DJj123dj)
+[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.4-brightgreen.svg?style=flat-square)](https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.4)  [![Sponsor DJj123dj](https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors)](https://github.com/sponsors/DJj123dj)

 This is the Security Policy of Open Ticket!<br>
 Here you can find a list of all supported & deprecated versions of the bot.<br>
@@ -11,20 +11,22 @@ You will also find some guidelines about how to report vulnerabilities, bugs & e
 Below, you can find a list with the status of every Open Ticket version.<br>
 This list will be updated on every release.

- 🟦 Early Access **(ideas, bugs, support, html transcripts)**
+- 🟦 In Development **(ideas, bugs, support, html transcripts)**
 - ✅ Supported **(features, bugs, support, docs, html transcripts)**
 - 🚧 Maintenance **(support, docs, html transcripts)**
 - 🟧 Deprecated **(docs)**
 - ❌ Fully Deprecated

-| Version    | Supported | Notes                          |
-|------------|-----------|--------------------------------|
-| 4.0.0-beta | 🟦        | For v4.0.0 Full Release        |
-| 3.5.8      | ✅        | Supported until October 2024   |
-| 3.5.7      | ✅        | Supported until September 2024 |
-| 3.5.6      | 🟧        | Documentation Only             |
-| < 3.5.6    | 🟧        | Documentation Only             |
-| < 3.5.0    | ❌        |                                |
+| Version    | Supported | Notes                                    |
+|------------|-----------|------------------------------------------|
+| 4.1.0      | 🟦        |                                          |
+| 4.0.4      | ✅        |                                          |
+| 4.0.3      | ✅        | Transcripts v2.0 (Offline August 2025)   |
+| 4.0.2      | 🚧        | Major discord.js bug                     |
+| 4.0.1      | 🚧        |                                          |
+| 4.0.0      | 🚧        | Supported until June 2025 (LTS)          |
+| 3.5.9      | 🟧        | Documentation Only                       |
+| < 3.5.9    | ❌        |                                          |

 ### 🕷️ Reporting Vulnerabilities
 You can report vulnerabilities, errors & bugs using one of the following methods:
@@ -46,4 +48,4 @@ If possible, try to provide screenshots!
 **Security Policy**<br>
 [changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be)<br>

-© 2024 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
@@ -1,16 +1,22 @@
 node_modules/
 package-lock.json
+.vscode/
+
 devconfig/
 devdatabase/
+plugins/*
+!plugins/example-plugin/
+database/openticket.sqlite
+dist/
+
 otdebug.txt
+
 .DS_Store
 */.DS_Store
 */*/.DS_Store
 */*/*/.DS_Store
 **/.DS_Store
-TEMP/
-.vscode/
-plugins/*
-!plugins/example-plugin/
-dist/
-database/openticket.sqlite
+
+.docs/*
+!.docs/createDocs.js
+!.docs/typedoc-config.json
@@ -8,31 +8,31 @@
 <br>Powered By<br>
 <img src="https://apis.dj-dj.be/cdn/opendiscord/logo.png" alt="Open Ticket" width="170px"><br>
 <a href="https://discord.com/invite/26vT9wt3n3"><img alt="Discord Invite Link" src="https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord"></img></a>
-<a href="https://github.com/DJj123dj/open-ticket/releases/tag/v4.0.0"><img alt="Open Ticket Version" src="https://img.shields.io/badge/version-4.0.0-brightgreen.svg?style=flat-square"></img></a>
+<a href="https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.4"><img alt="Open Ticket Version" src="https://img.shields.io/badge/version-4.0.4-brightgreen.svg?style=flat-square"></img></a>
 <a href="https://otdocs.dj-dj.be"><img alt="Open Ticket Documentation" src="https://img.shields.io/badge/discord.js-v14-CB3837.svg?style=flat-square&logo=npm"></img></a>
-<a href="https://github.com/DJj123dj/open-ticket/blob/main/LICENSE"><img alt="Open Ticket License" src="https://img.shields.io/badge/license-GPL%203.0-important.svg?style=flat-square"></img></a>
+<a href="https://github.com/open-discord-bots/open-ticket/blob/main/LICENSE"><img alt="Open Ticket License" src="https://img.shields.io/badge/license-GPL%203.0-important.svg?style=flat-square"></img></a>
 <a href="https://otdocs.dj-dj.be"><img alt="Open Ticket Stars" src="https://img.shields.io/github/stars/djj123dj/open-ticket?color=yellow&label=stars&logo=github&style=flat-square"></img></a>
+<br>
 <a href="https://github.com/sponsors/DJj123dj"><img alt="Sponsor DJj123dj" src="https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors"></img></a>
+<a href="https://hub.docker.com/repository/docker/djj123dj/open-ticket"><img alt="Open Ticket supports Docker!" src="https://img.shields.io/badge/docker-supported-2496ED?style=flat-square&logo=docker"></img></a>
+<a href=".eggs/README.md"><img alt="Open Ticket supports Pterodactyl Eggs!" src="https://img.shields.io/badge/pterodactyl-supported-10539F?style=flat-square&logo=pterodactyl"></img></a>
 </p>

 <p align="center">
 Open Ticket is the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes <code>Html Transcripts</code>, <code>Advanced Plugins</code>, <code>Custom Embeds</code>, <code>Questions/Modals</code>, <code>Stats</code> & more!
-You're also able to customise every little aspect of the bot! From embeds to transcripts. Open Ticket is also translated in more than <code>22 Languages</code>! If you need any help, feel free to join our <a href="https://discord.dj-dj.be">discord server</a>!
+You're also able to customise every little aspect of the bot! From embeds to transcripts. Open Ticket is also translated in more than <code>27 Languages</code>! If you need any help, feel free to join our <a href="https://discord.dj-dj.be">discord server</a>!
 </p>

 <p align="center"><b>⭐️ Help us grow by giving a star! ⭐️</b></p>

-> [!WARNING]  
-> Open Ticket v4 is still in beta! Please report all bugs in our [discord server](https://discord.dj-dj.be)!<br>
-> The translation count may not be accurate!
-
 ### 📌 Features
+- **🦇 pterodactyl support** - Open Ticket works perfect on Pterodactyl based panels! [(Download official eggs)](.eggs/README.md)
 - **💩 no bloat** - Your Open Ticket bot doesn't contain any form of bloat or credits!
- **🔒 tested & secure** - Open Ticket has been tested by thousands of servers and is very secure!
+- **🔒 tested & secure** - Open Ticket has been battletested by thousands of servers and is very secure!
 - **📈 scalable** - Open Ticket is made to handle huge servers! (Already tested in **servers with 100k members**)
 - **📄 HTML transcripts** - Make use of the most customisable, beautiful and easy-to-use HTML Transcripts!
- **✅ ticket actions** - Close, Reopen, Delete, Rename & Move all your tickets!
- **🇬🇧 translation** - Open Ticket has been translated in more than **22 languages** by our community!
+- **✅ ticket actions** - Close, Reopen, Delete, Claim, Pin, Rename & Move all your tickets!
+- **🇬🇧 translation** - Open Ticket has been translated in more than **27 languages** by our community!
 - **🎨 customisation** - Open Ticket has been created around customisation, everything can be customised!
 - **🖥️ interactions** - The bot has full support for Buttons, Dropdowns, Slash Commands and Modals!
 - **∞ unlimited** - Create an infinite amount of tickets & panels!
@@ -53,26 +53,25 @@ You're also able to customise every little aspect of the bot! From embeds to tra
  - **🔄 rotating status** - Create a rotating bot status & use dynamic variables from the bot!
  - **💾 sqlite database** - Use an `sqlite` database for increased performances!
  - **🎉 custom embeds** - Create your own embeds and use them in your server!
+  - **⏰ reminders** - Create & manage customisable reminders in your server!
  - **🎨 customisation** - Yep, you heard it right! Even more customisation!
  - **😁 And so much more...**

 > ### 📦 Resources
-> Resources might not be accurate yet! *(because v4 is still in beta)*<br>
+> Not all resources are accurate yet! We are working on this.<br>
 > <a href="https://www.youtube.com/watch?v=2jK9kAf6ASU"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-tutorial.png" alt="Open Ticket Tutorial" width="180px"></a>
-> <a href="https:/otdocs.dj-dj.be"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-docs.png" alt="Open Ticket Docs" width="180px"></a>
-> <a href="https://github.com/DJj123dj/open-discord-plugins"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-plugins.png" alt="Open Ticket Plugins" width="180px"></a>
+> <a href="https://openticket.dj-dj.be/message.html?msg=The%20current%20tutorial%20is%20outdated,%20we%27re%20still%20working%20on%20a%20new%20one!"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-docs.png" alt="Open Ticket Docs" width="180px"></a>
+> <a href="https://github.com/open-discord-bots/plugins"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-plugins.png" alt="Open Ticket Plugins" width="180px"></a>

 ### ❤️ Sponsors
 A big thanks to all our sponsors! Without them, it wouldn't be possible to create this project!

 <table>
 <tr>
-<td><img src="https://github.com/roppl3r.png" alt="Profile Picture" width="80px"></td>
-<td><img src="https://github.com/BENZORICH.png" alt="Profile Picture" width="80px"></td>
+<td><img src="https://github.com/roppl3r.png" alt="Profile Picture" width="100px"></td>
 </tr>
 <tr>
-<th><a href="https://github.com/roppl3r">roppl3r</a></th>
-<th><a href="https://github.com/BENZORICH">BENZORICH</a></th>
+<td align="center"><a href="https://github.com/roppl3r"><b>roppl3r</b></a></td>
 </tr>
 </table>

@@ -81,55 +80,142 @@ A big thanks to all our sponsors! Without them, it wouldn't be possible to creat
 <img src="https://github.com/SpyEye2.png" alt="SpyEye" width="40px">
 <img src="https://github.com/mods-hd.png" alt="Mods HD" width="40px">
 <img src="https://github.com/DOSEV5.png" alt="DOSEV5" width="40px">
+<img src="https://github.com/BENZORICH.png" alt="BENZORICH" width="40px">
 </a>

+### ⏱️ Quick Setup
+> 1. Download the latest version of Open Ticket on [Github](https://github.com/open-discord-bots/open-ticket).
+> 2. Make sure node.js & npm are installed using `node -v` (minimum `v18`).
+> 3. Install any required dependencies using `npm install`.
+> 4. Configure the bot in the `./config/` directory.
+> 5. Start the bot using `npm start` or `node index.js`
+>    - The bot will let you know any existing config errors.
+>    - Fix these errors and restart the bot.
+> 6. Enjoy using Open Ticket!
+> ### [📔 Visit Documentation](https://otdocs.dj-dj.be)
+
 ## 📸 Preview
-<img alt="Ticket Message" width="350px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/ticket.png">
-<img alt="Ticket Stats Message" width="350px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/stats.png">
-<img alt="Example Panel 1" width="350px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/panel-1.png">
-<img alt="Example Panel 2" width="350px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/panel-2.png">
+<img alt="An example of a panel." src="https://apis.dj-dj.be/cdn/openticket/preview-v4/panel-examples.png">
+<img alt="An example of a ticket message." src="https://apis.dj-dj.be/cdn/openticket/preview-v4/ticket-example.png">
+<img alt="Examples of built-in commands." src="https://apis.dj-dj.be/cdn/openticket/preview-v4/command-examples.png">
+
+## 🛠️ Contributors
+### 🖥️ Team & Contributors
+A list of people that contributed or provided the most support for Open Ticket.
+<table>
+<tr>
+<td align="center"><img src="https://github.com/DJj123dj.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/smetsliam.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/FrankVissers.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/Sank34.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/Roppl3r.png" alt="Profile Picture" width="80px"></td>
+</tr>
+<tr>
+<th><a href="https://github.com/DJj123dj">💻 DJj123dj</a></th>
+<th><a href="https://github.com/smetsliam">💬 smetsliam</a></th>
+<th><a href="https://github.com/FrankVissers">💬 Frank Vissers</a></th>
+<th><a href="https://github.com/Sank34">💬 Sanke</a></th>
+<th><a href="https://github.com/Roppl3r">🧩 Roppl3r</a></th>
+</tr>
+</table>
+
+### 💬 Translators
+Without our translators, it wouldn't be possible to translate Open Ticket in so many languages!
+- 🟢 Available - 🤖 Made Using AI - 🔴 Unavailable/Outdated
+
+|🔍 |Language             |Maintainer (Github/Discord) |
+|---|---------------------|----------------------------|
+|🟢 |🇬🇧 English            |djj123dj                   |
+|🟢 |🇳🇱 Dutch              |djj123dj                   |
+|🟢 |🇩🇪 German             |benzorich                  |
+|🟢 |🇪🇸 Spanish            |redactado & josuens        |
+|🟢 |🇵🇹 Portuguese         |quiradon                   |
+|🟢 |❓ Catalan            |guillee3                   |
+|🟢 |🇨🇿 Czech              |spyeye_                    |
+|🟢 |🇭🇺 Hungarian          |kornel0706                 |
+|🟢 |🇷🇴 Romanian           |sankedev                   |
+|🟢 |🇺🇦 Ukrainian          |anderskiy                  |
+|🟢 |🇮🇩 Indonesian         |erxg                       |
+|🟢 |🇮🇹 Italian            |fraden1mvp.                |
+|🟢 |🇩🇰 Danish             |the_gamer                  |
+|🟢 |🇹🇭 Thai               |modshd                     |
+|🟢 |🇹🇷 Turkish            |palestinian                |
+|🟢 |🇫🇷 French             |guillee.3                  |
+|🟢 |🇦🇪 Arabic             |palestinian                |
+|🟢 |🇮🇳 Hindi              |an_developer               |
+|🟢 |🇱🇹 Lithuanian         |tsgindrius                 |
+|🟢 |🇵🇱 Polish             |danoglez                   |
+|🟢 |🇳🇴 Norwegian          |NoOneNook                  |
+|🟢 |🇸🇪 Swedish            |NoOneNook                  |
+|🤖 |🇪🇪 Estonian           |iamnotmega                 |
+|🤖 |🇫🇮 Finnish            |iamnotmega                 |
+|🤖 |🇷🇺 Russian            |NoOneNook                  |
+|🤖 |🇱🇻 Latvian            |NoOneNook                  |
+|🤖 |🇻🇳 Vietnamese         |ngocdiep2006               |
+|🔴 |🇯🇵 Japanese           |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇰🇷 Korean             |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇨🇳 Simplified Chinese |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇨🇳 Traditional Chinese|[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇸🇮 Slovenian          |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇬🇷 Greek              |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |❓ Kurdish            |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |❓ Persian            |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+
+## ⭐️ Star History
+Please give this repository a star if you like it.  
+This will help us grow and reach even more people!
+
+<a href="https://star-history.com/#open-discord-bots/open-ticket&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=open-discord-bots/open-ticket&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=open-discord-bots/open-ticket&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=open-discord-bots/open-ticket&type=Date" />
+ </picture>
+</a>

 ## 🧩 Plugins
-**Download all plugins in our [Official Plugin Repository](https://github.com/DJj123dj/open-discord-plugins)!**<br>
+**Download all plugins in our [Official Plugin Repository](https://github.com/open-discord-bots/plugins)!**<br>
 > #### ⭐ Featured Plugins (Top 5 Most Used)
-> **[`ot-sqlite-database`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-sqlite-database/),
-> [`ot-migrate-v3`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-migrate-v3/),
-> [`ot-reviews`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-reviews/),
-> [`ot-feedback`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-feedback/),
-> [`ot-tags`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-tags/)**
+> **[`ot-sqlite-database`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-sqlite-database/),
+> [`ot-migrate-v3`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-migrate-v3/),
+> [`ot-reviews`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-reviews/),
+> [`ot-feedback`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-feedback/),
+> [`ot-tags`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-tags/)**

 ### 📦 Official *(made by DJdj Development)*
 |Name                                                                  |Category                    |Description              |
 |----------------------------------------------------------------------|----------------------------|-------------------------|
-|[`example-plugin`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/example-plugin/)                     |📄 Example                  |This is just an example plugin for people that want to create their own plugin. |
-|[`example-command`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/example-command/)                   |📄 Example                  |Sample custom command using the Open Discord system. |
-|[`ot-jump-to-top`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-jump-to-top/)                     |📢 Command                  |Add a simple command to jump to the top of the ticket. |
-|[`ot-kill-switch`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-kill-switch/)                     |📢 Command                  |Temporarily disable the ticket system using a kill switch. |
-|[`ot-hosting-status`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-hosting-status/)               |📢 Command                  |A simple command to send hosting status updates to a channel. |
-|[`ot-shutdown`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-shutdown/)                           |📢 Command                  |A simple command to turn off the bot from a slash command (server & bot owner only). |
-|[`ot-sqlite-database`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-sqlite-database/)             |⚙️ Utility                  |With this plugin, the database will be an SQLite file. It's a must-have for large servers! |
-|[`ot-no-slash-clear`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-no-slash-clear/)               |⚙️ Utility                  |Disable the automatic removal of slash commands that aren't used by Open Ticket. |
-|[`ot-migrate-v3`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-migrate-v3/)                       |⚙️ Utility                  |Use this plugin to migrate all tickets from Open Ticket v3 to v4. |
-|[`ot-ticket-message-extras`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-ticket-message-extras/) |🎨 Customisation            |A plugin which adds a few little features to the ticket message. |
-|[`ot-rename-keep-prefix`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-rename-keep-prefix/)       |🎨 Customisation            |Simple plugin to keep the channel prefix when using the /rename command. |
-|[`ot-customise-buttons`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-customise-buttons/)         |🎨 Customisation            |Customise almost all built-in buttons. This includes the claim, reopen, close & delete buttons. |
-|[`ot-ephemeral-messages`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-ephemeral-messages/)       |🎨 Customisation            |Customise for every messages if it needs to be ephemeral or not. |
-|[`ot-footers`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-footers/)                             |🎨 Customisation            |A simple plugin to add footers in all Open Ticket embeds. |
-|[`ot-alt-detector`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-alt-detector/)                   |💼 Management               |Use the discord-alt-detector npm package by DJdj Development in your ticket bot. |
-|[`ot-embeds`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-embeds/)                               |💼 Management               |Create custom premade embeds in the config or use the command to create one from scratch. |
-|[`ot-move-actions`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-move-actions/)                   |💼 Management               |Automatically unclaim/unpin a ticket when it's moved using `/move`. |
-|[`ot-reviews`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-reviews/)                             |💼 Management               |Review system for Open Ticket! It is very customisable and has lots of features. |
-|[`ot-tags`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-tags/)                                   |💼 Management               |Use tags to quickly reply with a pre-existing text. |
-|[`ot-better-status`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-better-status/)                 |🤖 Client                   |An advanced status plugin to rotate between states. It also allows for the use of variables. |
+|[`example-plugin`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/example-plugin/)                     |📄 Example                  |This is just an example plugin for people that want to create their own plugin. |
+|[`example-command`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/example-command/)                   |📄 Example                  |Sample custom command using the Open Discord system. |
+|[`ot-jump-to-top`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-jump-to-top/)                     |📢 Command                  |Add a simple command to jump to the top of the ticket. |
+|[`ot-kill-switch`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-kill-switch/)                     |📢 Command                  |Temporarily disable the ticket system using a kill switch. |
+|[`od-hosting-status`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-hosting-status/)               |📢 Command                  |A simple command to send hosting status updates to a channel. |
+|[`od-shutdown`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-shutdown/)                           |📢 Command                  |A simple command to turn off the bot from a slash command (server & bot owner only). |
+|[`ot-sqlite-database`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-sqlite-database/)             |⚙️ Utility                  |With this plugin, the database will be an SQLite file. It's a must-have for large servers! |
+|[`od-no-slash-clear`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-no-slash-clear/)               |⚙️ Utility                  |Disable the automatic removal of slash commands that aren't used by Open Ticket. |
+|[`ot-migrate-v3`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-migrate-v3/)                       |⚙️ Utility                  |Use this plugin to migrate all tickets from Open Ticket v3 to v4. |
+|[`ot-ticket-message-extras`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-ticket-message-extras/) |🎨 Customisation            |A plugin which adds a few little features to the ticket message. |
+|[`ot-rename-keep-prefix`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-rename-keep-prefix/)       |🎨 Customisation            |Simple plugin to keep the channel prefix when using the /rename command. |
+|[`ot-customise-buttons`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-customise-buttons/)         |🎨 Customisation            |Customise almost all built-in buttons. This includes the claim, reopen, close & delete buttons. |
+|[`ot-ephemeral-messages`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-ephemeral-messages/)       |🎨 Customisation            |Customise for every messages if it needs to be ephemeral or not. |
+|[`ot-footers`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-footers/)                             |🎨 Customisation            |A simple plugin to add footers in all Open Ticket embeds. |
+|[`od-alt-detector`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-alt-detector/)                   |💼 Management               |Use the discord-alt-detector npm package by DJdj Development in your ticket bot. |
+|[`ot-embeds`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-embeds/)                               |💼 Management               |Create custom premade embeds in the config or use the command to create one from scratch. |
+|[`ot-move-actions`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-move-actions/)                   |💼 Management               |Automatically unclaim/unpin a ticket when it's moved using `/move`. |
+|[`ot-reviews`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-reviews/)                             |💼 Management               |Review system for Open Ticket! It is very customisable and has lots of features. |
+|[`ot-tags`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-tags/)                                   |💼 Management               |Use tags to quickly reply with a pre-existing text. |
+|[`ot-better-status`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-better-status/)                 |🤖 Client                   |An advanced status plugin to rotate between states. It also allows for the use of variables. |

 ### ✅ Verified *(made by community)*
 |Name                                                                 |Author                      |Category                    |Description              |
 |---------------------------------------------------------------------|----------------------------|----------------------------|-------------------------|
-|[`ot-config-reload`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-config-reload/)                |guillee.3                   |⚙️ Utility                  |This plugin adds a new command that allows reloading the Open Ticket config files without the need for a restart. |
-|[`ot-ticket-forms`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-ticket-forms/)                  |guillee.3                   |💼 Management               |An advanced forms plugin for Open Ticket. |
-|[`ot-feedback`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-feedback/)                          |an_developer                |💼 Management               |A plugin to gather feedback of your support service. |
-|[`ot-assign-role`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-assign-role/)                    |rapid.fast                  |💼 Management               |This plugin assigns a predefined role to a user upon creating a ticket. |
-|[`ot-translate-cmds`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-translate-cmds/)              |guillee.3                   |🤖 Client                  |Translate all built-in command names, descriptions & options. |
+|[`ot-config-reload`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-config-reload/)                |guillee.3                   |⚙️ Utility                  |This plugin adds a new command that allows reloading the Open Ticket config files without the need for a restart. |
+|[`ot-ticket-forms`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-ticket-forms/)                  |guillee.3                   |💼 Management               |An advanced forms plugin for Open Ticket. |
+|[`ot-feedback`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-feedback/)                          |an_developer                |💼 Management               |A plugin to gather feedback of your support service. |
+|[`ot-assign-role`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-assign-role/)                    |rapid.fast                  |💼 Management               |This plugin assigns a predefined role to a user upon creating a ticket. |
+|[`ot-volume-warning`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-volume-warning/)              |guillee.3                   |💼 Management               |Alerts ticket creators when too many tickets are open, indicating possible response delays. |
+|[`od-reminders`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-reminders/)                        |guillee.3                   |💼 Management               |Set reminders that will be sent to a channel every specified time. |
+|[`ot-translate-cmds`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-translate-cmds/)              |guillee.3                   |🤖 Client                  |Translate all built-in command names, descriptions & options. |

 ### 📢 Categories
 - **📄 Example** - These plugins serve as an example or starting template.
@@ -139,76 +225,10 @@ A big thanks to all our sponsors! Without them, it wouldn't be possible to creat
 - **💼 Management** - These plugins add features that help you manage your server.
 - **🤖 Client** - These plugins add features affecting the discord client or bot itself.

-## 🛠️ Contributors
-### 🖥️ Team
-This is the main team working on Open Ticket. Don't forget to check their profiles!
-<table>
-<tr>
-<td><img src="https://github.com/DJj123dj.png" alt="Profile Picture" width="80px"></td>
-<td><img src="https://github.com/Sank34.png" alt="Profile Picture" width="80px"></td>
-<td><img src="https://github.com/smetsliam.png" alt="Profile Picture" width="80px"></td>
-</tr>
-<tr>
-<th><a href="https://github.com/DJj123dj">💻 DJj123dj</a></th>
-<th><a href="https://github.com/Sank34">💬 Sanke</a></th>
-<th><a href="https://github.com/smetsliam">💬 DevBack</a></th>
-</tr>
-</table>
-
-### 💬 Translators
-|Language             |Maintainer (discord name) |Status                       |
-|---------------------|--------------------------|-----------------------------|
-|🇬🇧 English            |djj123dj                  |🟢 Up To Date                |
-|🇳🇱 Dutch              |djj123dj                  |🟢 Up To Date                |
-|🇩🇪 German             |benzorich                 |🟢 Up To Date                |
-|🇪🇸 Spanish            |redactado & josuens       |🟢 Up To Date                |
-|🇵🇹 Portuguese         |quiradon                  |🟢 Up To Date                |
-|❓ Catalan            |guillee3                  |🟢 Up To Date                |
-|🇨🇿 Czech              |spyeye_                   |🟢 Up To Date                |
-|🇭🇺 Hungarian          |kornel0706                |🟢 Up To Date                |
-|🇷🇴 Romanian           |sankedev                  |🟢 Up To Date                |
-|🇺🇦 Ukrainian          |anderskiy                 |🟢 Up To Date                |
-|🇮🇩 Indonesian         |erxg                      |🟢 Up To Date                |
-|🇮🇹 Italian            |fraden1mvp.               |🟢 Up To Date                |
-|🇩🇰 Danish             |the_gamer                 |🟢 Up To Date                |
-|🇹🇭 Thai               |modshd                    |🟢 Up To Date                |
-|🇹🇷 Turkish            |palestinian               |🟢 Up To Date                |
-|🇫🇷 French             |guillee.3                 |🟢 Up To Date                |
-|🇦🇪 Arabic             |palestinian               |🟢 Up To Date                |
-|🇮🇳 Hindi              |an_developer              |🟢 Up To Date                |
-|🇱🇹 Lithuanian         |tsgindrius                |🟢 Up To Date                |
-|🇵🇱 Polish             |danoglez                  |🟢 Up To Date                |
-|🇪🇪 Estonian           |iamnotmega                |🔵 Up To Date (ChatGPT)      |
-|🇫🇮 Finnish            |iamnotmega                |🔵 Up To Date (ChatGPT)      |
-|🇷🇺 Russian            |apexo & ander             |🟠 Temporary Outdated (beta) |
-|🇳🇴 Norwegian          |noonenook                 |🟠 Temporary Outdated (beta) |
-|❓ Kurdish            |raze.hama                 |🟠 Temporary Outdated (beta) |
-|❓ Persian            |sasanwm                   |🟠 Temporary Outdated (beta) |
-|🇱🇻 Latvian            |ronalds1398               |🟠 Temporary Outdated (beta) |
-|🇯🇵 Japanese           |iamnotmega                |🟠 Temporary Outdated (beta) |
-|🇰🇷 Korean             |iamnotmega                |🟠 Temporary Outdated (beta) |
-|🇨🇳 Simplified Chinese |iamnotmega                |🟠 Temporary Outdated (beta) |
-|🇨🇳 Traditional Chinese|iamnotmega                |🟠 Temporary Outdated (beta) |
-|🇸🇪 Swedish            |iamnotmega                |🟠 Temporary Outdated (beta) |
-|🇻🇳 Vietnamese         |iamnotmega                |🟠 Temporary Outdated (beta) |
-|🇸🇮 Slovenian          |n1kkec                    |🔴 Outdated                  |
-|🇬🇷 Greek              |stefanos                  |🔴 Outdated                  |
-
-## ⭐️ Star History
-Please help us grow by giving a star! It would help us a lot!
-
-<a href="https://star-history.com/#DJj123dj/open-ticket&Date">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=DJj123dj/open-ticket&type=Date&theme=dark" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=DJj123dj/open-ticket&type=Date" />
-   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=DJj123dj/open-ticket&type=Date" />
- </picture>
-</a>
-
 ---
 <img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="170px">

 **README.md**<br>
-[changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be) - [license](./LICENSE.md)<br>
+[changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord server](https://discord.dj-dj.be) - [license](./LICENSE.md)<br>

-© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms) - [Privacy Policy](https://www.dj-dj.be/privacy) - [Support Us](https://github.com/sponsors/DJj123dj)
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms) - [Privacy Policy](https://www.dj-dj.be/privacy) - [Support Us](https://github.com/sponsors/DJj123dj)
@@ -2,7 +2,7 @@
    "_INFO":{
        "support":"https://otdocs.dj-dj.be",
        "discord":"https://discord.dj-dj.be",
-        "version":"open-ticket-v4.0.0"
+        "version":"open-ticket-v4.0.4"
    },
    
    "token":"your bot token here! (or leave empty when using 'tokenFromENV')",
@@ -17,7 +17,7 @@
            "image":"https://www.example.com/image.png (or leave empty)",
            "thumbnail":"https://www.example.com/image.png (or leave empty)",
            
-            "footer":"Open Ticket v4.0.0 (or leave empty)",
+            "footer":"Open Ticket v4.0.4 (or leave empty)",
            "fields":[
                {"name":"field name","value":"field value","inline":false}
            ],
@@ -49,7 +49,7 @@
        },
        "favicon":{
            "enableCustomFavicon":false,
-            "imageUrl":"https://transcripts.dj-dj.be/favicon.png"
+            "imageUrl":"https://t.dj-dj.be/favicon.png"
        }
    }
 }
@@ -4,6 +4,8 @@ services:
  openticket:
    build: .
    volumes:
-      - .:/app
-    environment: NODE_ENV=production
-    restart: unless-stopped
+      - openticket:/home/container
+    restart: no
+    container_name: open-ticket
+volumes:
+  openticket:
@@ -1,9 +1,9 @@
 # Docker File for Open Ticket v4
-# Use the official Node.js 18 image from Docker Hub
-FROM node:18-alpine
+# Use the official Node.js 20 image from Docker Hub
+FROM node:20-alpine

-# Set a different working directory inside the container
-WORKDIR /usr/src/openticket
+# Set pterodactyl working directory inside the container
+WORKDIR /home/container

 # Copy package.json and package-lock.json into the container
 COPY package*.json ./
@@ -14,7 +14,7 @@ process.argv.push(...flags)
 ██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║       ██║   ██║██║     ██╔═██╗ ██╔══╝     ██║     
 ╚██████╔╝██║     ███████╗██║ ╚████║       ██║   ██║╚██████╗██║  ██╗███████╗   ██║     
 ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝       ╚═╝   ╚═╝ ╚═════╝╚═╝  ╚═╝╚══════╝   ╚═╝     
- v4.0.0 - Made by DJj123dj & Contributors
+ v4.0.4 - Made by DJj123dj & Contributors

 Discord: https://discord.dj-dj.be
 Docs: https://otdocs.dj-dj.be
@@ -45,7 +45,7 @@ function computeSourceHash(dir,upperHash){
    
    for (const file of info) {
        const fullPath = nodepath.join(dir,file.name)
-        if (file.isFile()){
+        if (file.isFile() && [".js",".ts",".jsx",".tsx"].some((ext) => file.name.endsWith(ext))){
            const statInfo = fs.statSync(fullPath)
            //compute hash using file metadata
            const fileInfo = `${fullPath}:${statInfo.size}:${statInfo.mtimeMs}`
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION": {
-        "otversion": "v4.0.0",
+        "otversion": "v4.0.4",
        "translators": ["palestinian"],
        "lastedited": "06/12/2024",
        "language": "Arabic",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["guillee3"],
        "lastedited":"21/08/2024",
        "language":"Catalan",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["DJj123dj"],
        "lastedited":"21/08/2024",
        "language":"Custom",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["spyeye_"],
        "lastedited":"21/08/2024",
        "language":"Czech",
@@ -1,6 +1,6 @@
 {
  "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["the_gamer"],
        "lastedited":"26/09/2024",
        "language":"Danish",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["DJj123dj"],
        "lastedited":"21/08/2024",
        "language":"Dutch",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["DJj123dj"],
        "lastedited":"21/08/2024",
        "language":"English",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["iamnotmega","ChatGPT"],
        "lastedited":"21/10/2024",
        "language":"Estonian",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["iamnotmega","ChatGPT"],
        "lastedited":"21/10/2024",
        "language":"Finnish",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["guillee3"],
        "lastedited":"04/12/2024",
        "language":"French",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["benzorich"],
        "lastedited":"06/10/2024",
        "language":"German",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["an_developer"],
        "lastedited":"14/12/2024",
        "language":"Hindi",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["Kornel0706"],
        "lastedited":"22/08/2024",
        "language":"Hungarian",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["erxg"],
        "lastedited":"25/08/2024",
        "language":"Indonesian",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["fraden1mvp."],
        "lastedited":"08/10/2024",
        "language":"Italian",
@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.4",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Latvian",
+        "automated": false
+    },
+    "checker": {
+        "system": {
+            "typeError": "[KĻŪDA]",
+            "headerOpenTicket": "ATVĒRT BIĻETI",
+            "typeWarning": "[BRĪDINĀJUMS]",
+            "typeInfo": "[INFORMĀCIJA]",
+            "headerConfigChecker": "KONFIGURĀCIJAS PĀRBAUDĪTĀJS",
+            "headerDescription": "pārbaudiet kļūdas savos konfigurācijas failos!",
+            "footerError": "bots netiks startēts, kamēr visas {0} nebūs izlabotas!",
+            "footerWarning": "ieteicams izlabot visas {0} pirms startēšanas!",
+            "footerSupport": "ATBALSTS: {0} - DOKUMENTI: {1}",
+            "compactInformation": "izmantojiet {0}, lai iegūtu vairāk informācijas!",
+            "dataPath": "ceļš",
+            "dataDocs": "dokumenti",
+            "dataMessages": "ziņojums"
+        },
+        "messages": {
+            "stringTooShort": "Šis teksts nedrīkst būt īsāks par {0} rakstzīmēm!",
+            "stringTooLong": "Šis teksts nedrīkst būt garāks par {0} rakstzīmēm!",
+            "stringLengthInvalid": "Šim tekstam jābūt {0} rakstzīmju garam!",
+            "stringStartsWith": "Šim tekstam jāsākas ar {0}!",
+            "stringEndsWith": "Šim tekstam jābeidzas ar {0}!",
+            "stringContains": "Šim tekstam jāsatur {0}!",
+            "stringChoices": "Šis teksts var būt tikai viena no šīm vērtībām: {0}!",
+            "stringRegex": "Šis teksts ir nederīgs!",
+
+            "numberTooShort": "Šis skaitlis nedrīkst būt īsāks par {0} rakstzīmēm!",
+            "numberTooLong": "Šis skaitlis nedrīkst būt garāks par {0} rakstzīmēm!",
+            "numberLengthInvalid": "Šim skaitlim jābūt {0} rakstzīmju garam!",
+            "numberTooSmall": "Šim skaitlim jābūt vismaz {0}!",
+            "numberTooLarge": "Šim skaitlim jābūt ne vairāk kā {0}!",
+            "numberNotEqual": "Šim skaitlim jābūt {0}!",
+            "numberStep": "Šim skaitlim jābūt {0} reizinājumam!",
+            "numberStepOffset": "Šim skaitlim jābūt {0} reizinājumam, sākot ar {1}!",
+            "numberStartsWith": "Šim skaitlim jāsākas ar {0}!",
+            "numberEndsWith": "Šim skaitlim jābeidzas ar {0}!",
+            "numberContains": "Šim skaitlim jāsatur {0}!",
+            "numberChoices": "Šis skaitlis var būt tikai viena no šīm vērtībām: {0}!",
+            "numberFloat": "Šis skaitlis nedrīkst būt decimāldaļa!",
+            "numberNegative": "Šis skaitlis nedrīkst būt negatīvs!",
+            "numberPositive": "Šis skaitlis nedrīkst būt pozitīvs!",
+            "numberZero": "Šis skaitlis nedrīkst būt nulle!",
+
+            "booleanTrue": "Šis loģiskais mainīgais nedrīkst būt patiess!",
+            "booleanFalse": "Šis loģiskais mainīgais nedrīkst būt nepatiess!",
+
+            "arrayEmptyDisabled": "Šis masīvs nedrīkst būt tukšs!",
+            "arrayEmptyRequired": "Šim masīvam jābūt tukšam!",
+            "arrayTooShort": "Šim masīvam jābūt vismaz {0} garam!",
+            "arrayTooLong": "Šim masīvam jābūt ne garākam par {0}!",
+            "arrayLengthInvalid": "Šim masīvam jābūt {0} garam!",
+            "arrayInvalidTypes": "Šis masīvs var saturēt tikai šādus tipus: {0}!",
+            "arrayDouble": "Šis masīvs neatļauj vienādas vērtības divreiz!",
+
+            "discordInvalidId": "Šis ir nederīgs Discord {0} ID!",
+            "discordInvalidIdOptions": "Šis ir nederīgs Discord {0} ID! Jūs varat izmantot arī kādu no šiem: {1}!",
+            "discordInvalidToken": "Šis ir nederīgs Discord tokens (sintaktiski)!",
+            "colorInvalid": "Šī ir nederīga heksadecimālā krāsa!",
+            "emojiTooShort": "Šim tekstam jābūt vismaz {0} emocijzīmēm!",
+            "emojiTooLong": "Šim tekstam jābūt ne vairāk kā {0} emocijzīmēm!",
+            "emojiCustom": "Šī emocijzīme nedrīkst būt pielāgota Discord emocijzīme!",
+            "emojiInvalid": "Šī ir nederīga emocijzīme!",
+            "urlInvalid": "Šī URL ir nederīga!",
+            "urlInvalidHttp": "Šī URL var izmantot tikai https:// protokolu!",
+            "urlInvalidProtocol": "Šī URL var izmantot tikai http:// un https:// protokolus!",
+            "urlInvalidHostname": "Šai URL ir neatļauts resursdatora nosaukums!",
+            "urlInvalidExtension": "Šai URL ir nederīgs paplašinājums! Izvēlieties starp: {0}!",
+            "urlInvalidPath": "Šai URL ir nederīgs ceļš!",
+            "idNotUnique": "Šis ID nav unikāls, izmantojiet citu ID!",
+            "idNonExistent": "ID {0} neeksistē!",
+
+            "invalidType": "Šai īpašībai jābūt tipam: {0}!",
+            "propertyMissing": "Īpašība {0} trūkst šajā objektā!",
+            "propertyOptional": "Īpašība {0} šajā objektā ir izvēles!",
+            "objectDisabled": "Šis objekts ir atspējots, aktivizējiet to, izmantojot {0}!",
+            "nullInvalid": "Šī īpašība nedrīkst būt null!",
+            "switchInvalidType": "Tam jābūt vienam no šiem tipiem: {0}!",
+            "objectSwitchInvalid": "Šim objektam jābūt vienam no šiem tipiem: {0}!",
+
+            "invalidLanguage": "Šī ir nederīga valoda!",
+            "invalidButton": "Šai pogai jābūt vismaz {0} vai {1}!",
+            "unusedOption": "Opcija {0} nekur netiek izmantota!",
+            "unusedQuestion": "Jautājums {0} nekur netiek izmantots!",
+            "dropdownOption": "Panelim ar iespējotu izvēlni var būt tikai 'ticket' tipa opcijas!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Apmeklēt biļeti",
+            "close": "Aizvērt biļeti",
+            "delete": "Dzēst biļeti",
+            "reopen": "Atvērt biļeti no jauna",
+            "claim": "Pieprasīt biļeti",
+            "unclaim": "Atcelt biļetes pieprasījumu",
+            "pin": "Piespraust biļeti",
+            "unpin": "Atspraust biļeti",
+            "clear": "Dzēst biļetes",
+            "helpSwitchSlash": "Skatīt slīpsvītras komandas",
+            "helpSwitchText": "Skatīt teksta komandas",
+            "helpPage": "Lapa {0}",
+            "withReason": "Ar iemeslu",
+            "withoutTranscript": "Bez transkripta"
+        },
+        "titles": {
+            "created": "Biļete izveidota",
+            "close": "Biļete aizvērta",
+            "delete": "Biļete dzēsta",
+            "reopen": "Biļete atkal atvērta",
+            "claim": "Biļete pieprasīta",
+            "unclaim": "Biļetes pieprasījums atcelts",
+            "pin": "Biļete piesprausta",
+            "unpin": "Biļete atsprausta",
+            "rename": "Biļete pārdēvēta",
+            "move": "Biļete pārvietota",
+            "add": "Lietotājs pievienots biļetei",
+            "remove": "Lietotājs noņemts no biļetes",
+
+            "help": "Pieejamās komandas",
+            "statsReset": "Atiestatīt statistiku",
+            "blacklistAdd": "Lietotājs pievienots melnajam sarakstam",
+            "blacklistRemove": "Lietotājs atbrīvots",
+            "blacklistGet": "Melnajā sarakstā esošs lietotājs",
+            "blacklistView": "Pašreizējais melnais saraksts",
+            "blacklistAddDm": "Pievienots melnajam sarakstam",
+            "blacklistRemoveDm": "Noņemts no melnā saraksta",
+            "clear": "Biļetes izdzēstas",
+            "roles": "Lomas atjauninātas",
+
+            "autoclose": "Biļete automātiski aizvērta",
+            "autocloseEnabled": "Automātiskā aizvēršana ieslēgta",
+            "autocloseDisabled": "Automātiskā aizvēršana izslēgta",
+            "autodelete": "Biļete automātiski dzēsta",
+            "autodeleteEnabled": "Automātiskā dzēšana ieslēgta",
+            "autodeleteDisabled": "Automātiskā dzēšana izslēgta"
+        },
+        "descriptions": {
+            "create": "Jūsu biļete ir izveidota. Noklikšķiniet uz pogas zemāk, lai tai piekļūtu!",
+            "close": "Biļete ir veiksmīgi aizvērta!",
+            "delete": "Biļete ir veiksmīgi dzēsta!",
+            "reopen": "Biļete ir veiksmīgi atkal atvērta!",
+            "claim": "Biļete ir veiksmīgi pieprasīta!",
+            "unclaim": "Biļetes pieprasījums ir veiksmīgi atcelts!",
+            "pin": "Biļete ir veiksmīgi piesprausta!",
+            "unpin": "Biļete ir veiksmīgi atsprausta!",
+            "rename": "Biļete ir veiksmīgi pārdēvēta par {0}!",
+            "move": "Biļete ir veiksmīgi pārvietota uz {0}!",
+            "add": "{0} ir veiksmīgi pievienots biļetei!",
+            "remove": "{0} ir veiksmīgi noņemts no biļetes!",
+
+            "helpExplanation": "`<nosaukums>` => obligāts parametrs\n`[nosaukums]` => izvēles parametrs",
+            "statsReset": "Bota statistika ir veiksmīgi atiestatīta!",
+            "statsError": "Nevar skatīt biļešu statistiku!\n{0} nav biļete!",
+            "blacklistAdd": "{0} ir veiksmīgi pievienots melnajam sarakstam!",
+            "blacklistRemove": "{0} ir veiksmīgi atbrīvots!",
+            "blacklistGetSuccess": "{0} pašlaik ir melnajā sarakstā!",
+            "blacklistGetEmpty": "{0} pašlaik nav melnajā sarakstā!",
+            "blacklistViewEmpty": "Vēl neviens nav melnajā sarakstā!",
+            "blacklistViewTip": "Izmantojiet \"/blacklist add\", lai pievienotu lietotāju melnajam sarakstam!",
+            "clearVerify": "Vai esat pārliecināts, ka vēlaties dzēst vairākas biļetes?\nŠo darbību nevar atsaukt!",
+            "clearReady": "{0} biļetes ir veiksmīgi dzēstas!",
+            "rolesEmpty": "Neviena loma nav atjaunināta!",
+
+            "autocloseLeave": "Šī biļete tika automātiski aizvērta, jo izveidotājs pameta serveri!",
+            "autocloseTimeout": "Šī biļete tika automātiski aizvērta, jo tā bija neaktīva ilgāk par `{0}h`!",
+            "autodeleteLeave": "Šī biļete tika automātiski dzēsta, jo izveidotājs pameta serveri!",
+            "autodeleteTimeout": "Šī biļete tika automātiski dzēsta, jo tā bija neaktīva ilgāk par `{0} dienām`!",
+            "autocloseEnabled": "Automātiskā aizvēršana ir ieslēgta šai biļetei!\nTā tiks aizvērta, ja būs neaktīva ilgāk par `{0}h`!",
+            "autocloseDisabled": "Automātiskā aizvēršana ir izslēgta šai biļetei!\nTā vairs netiks automātiski aizvērta!",
+            "autodeleteEnabled": "Automātiskā dzēšana ir ieslēgta šai biļetei!\nTā tiks dzēsta, ja būs neaktīva ilgāk par `{0} dienām`!",
+            "autodeleteDisabled": "Automātiskā dzēšana ir izslēgta šai biļetei!\nTā vairs netiks automātiski dzēsta!",
+
+            "ticketMessageLimit": "Jūs varat izveidot tikai {0} biļeti(-es) vienlaikus!",
+            "ticketMessageAutoclose": "Šī biļete tiks automātiski aizvērta, ja būs neaktīva {0}h!",
+            "ticketMessageAutodelete": "Šī biļete tiks automātiski dzēsta, ja būs neaktīva {0} dienas!",
+            "panelReady": "Paneli var atrast zemāk!\nŠo ziņojumu tagad var dzēst!"
+        },
+        "modal": {
+            "closePlaceholder": "Kāpēc jūs aizvērāt šo biļeti?",
+            "deletePlaceholder": "Kāpēc jūs dzēsāt šo biļeti?",
+            "reopenPlaceholder": "Kāpēc jūs atkal atvērāt šo biļeti?",
+            "claimPlaceholder": "Kāpēc jūs pieprasījāt šo biļeti?",
+            "unclaimPlaceholder": "Kāpēc jūs atcēlāt šīs biļetes pieprasījumu?",
+            "pinPlaceholder": "Kāpēc jūs piespraudāt šo biļeti?",
+            "unpinPlaceholder": "Kāpēc jūs atspraudāt šo biļeti?"
+        },
+        "logs": {
+            "createLog": "Jauna biļete tika izveidota no {0}!",
+            "closeLog": "Šī biļete tika aizvērta no {0}!",
+            "closeDm": "Jūsu biļete tika aizvērta mūsu serverī!",
+            "deleteLog": "Šī biļete tika dzēsta no {0}!",
+            "deleteDm": "Jūsu biļete tika dzēsta mūsu serverī!",
+            "reopenLog": "Šī biļete tika atkal atvērta no {0}!",
+            "reopenDm": "Jūsu biļete tika atkal atvērta mūsu serverī!",
+            "claimLog": "Šī biļete tika pieprasīta no {0}!",
+            "claimDm": "Jūsu biļete tika pieprasīta mūsu serverī!",
+            "unclaimLog": "Šīs biļetes pieprasījums tika atcelts no {0}!",
+            "unclaimDm": "Jūsu biļetes pieprasījums tika atcelts mūsu serverī!",
+            "pinLog": "Šī biļete tika piesprausta no {0}!",
+            "pinDm": "Jūsu biļete tika piesprausta mūsu serverī!",
+            "unpinLog": "Šī biļete tika atsprausta no {0}!",
+            "unpinDm": "Jūsu biļete tika atsprausta mūsu serverī!",
+            "renameLog": "Šī biļete tika pārdēvēta par {0} no {1}!",
+            "renameDm": "Jūsu biļete tika pārdēvēta par {0} mūsu serverī!",
+            "moveLog": "Šī biļete tika pārvietota uz {0} no {1}!",
+            "moveDm": "Jūsu biļete tika pārvietota uz {0} mūsu serverī!",
+            "addLog": "{0} tika pievienots šai biļetei no {1}!",
+            "addDm": "{0} tika pievienots jūsu biļetei mūsu serverī!",
+            "removeLog": "{0} tika noņemts no šīs biļetes no {1}!",
+            "removeDm": "{0} tika noņemts no jūsu biļetes mūsu serverī!",
+
+            "blacklistAddLog": "{0} tika pievienots melnajam sarakstam no {1}!",
+            "blacklistRemoveLog": "{0} tika noņemts no melnā saraksta no {1}!",
+            "blacklistAddDm": "Jūs esat pievienots melnajam sarakstam mūsu serverī!\nNo šī brīža jūs nevarat izveidot biļeti!",
+            "blacklistRemoveDm": "Jūs esat noņemts no melnā saraksta mūsu serverī!\nTagad jūs atkal varat izveidot biļetes!",
+            "clearLog": "{0} biļetes tika dzēstas no {1}!"
+        }
+    },
+"transcripts": {
+        "success": {
+            "visit": "Apmeklēt transkriptu",
+            "ready": "Transkripts izveidots",
+            "textFileDescription": "Šis ir dzēstas biļetes teksta transkripts!",
+            "htmlProgress": "Lūdzu, uzgaidiet, kamēr šis HTML transkripts tiek apstrādāts...",
+
+            "createdChannel": "Jauns {0} transkripts tika izveidots serverī!",
+            "createdCreator": "Jauns {0} transkripts tika izveidots vienai no jūsu biļetēm!",
+            "createdParticipant": "Jauns {0} transkripts tika izveidots vienā no biļetēm, kurā jūs piedalījāties!",
+            "createdActiveAdmin": "Jauns {0} transkripts tika izveidots vienā no biļetēm, kurā jūs piedalījāties kā administrators!",
+            "createdEveryAdmin": "Jauns {0} transkripts tika izveidots vienā no biļetēm, kurā jūs bijāt administrators!",
+            "createdOther": "Jauns {0} transkripts tika izveidots!"
+        },
+        "errors": {
+            "retry": "Mēģināt vēlreiz",
+            "continue": "Dzēst bez transkripta",
+            "backup": "Izveidot rezerves transkriptu",
+            "error": "Kaut kas nogāja greizi, mēģinot izveidot transkriptu.\nKo jūs vēlaties darīt?\n\nŠī biļete netiks dzēsta, kamēr jūs nenoklikšķināsiet uz vienas no šīm pogām."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Iekšēja kļūda",
+            "optionMissing": "Trūkst komandas opcijas",
+            "optionInvalid": "Nederīga komandas opcija",
+            "unknownCommand": "Nezināma komanda",
+            "noPermissions": "Nav atļauju",
+            "unknownTicket": "Nezināma biļete",
+            "deprecatedTicket": "Novecojusi biļete",
+            "unknownOption": "Nezināma opcija",
+            "unknownPanel": "Nezināms panelis",
+            "notInGuild": "Nav serverī",
+            "channelRename": "Nevar pārdēvēt kanālu",
+            "busy": "Biļete ir aizņemta"
+        },
+        "descriptions": {
+            "askForInfo": "Sazinieties ar šī bota īpašnieku, lai iegūtu plašāku informāciju!",
+            "askForInfoResolve": "Sazinieties ar bota īpašnieku, ja šī problēma neatrisinās pēc dažiem mēģinājumiem.",
+            "internalError": "Neizdevās atbildēt uz šo {0} iekšējas kļūdas dēļ!",
+            "optionMissing": "Šai komandai trūkst obligāta parametra!",
+            "optionInvalid": "Šīs komandas parametrs ir nederīgs!",
+            "optionInvalidChoose": "Izvēlieties starp",
+            "unknownCommand": "Mēģiniet apmeklēt palīdzības izvēlni, lai iegūtu vairāk informācijas!",
+            "noPermissions": "Jums nav atļauts izmantot šo {0}!",
+            "noPermissionsList": "Nepieciešamās atļaujas: (viena no tām)",
+            "noPermissionsCooldown": "Jums nav atļauts izmantot šo {0}, jo jums ir atpūtas periods!",
+            "noPermissionsBlacklist": "Jums nav atļauts izmantot šo {0}, jo esat melnajā sarakstā!",
+            "noPermissionsLimitGlobal": "Jūs nevarat izveidot biļeti, jo serveris ir sasniedzis maksimālo biļešu skaitu!",
+            "noPermissionsLimitGlobalUser": "Jūs nevarat izveidot biļeti, jo esat sasniedzis maksimālo biļešu skaitu!",
+            "noPermissionsLimitOption": "Jūs nevarat izveidot biļeti, jo serveris ir sasniedzis maksimālo biļešu skaitu šai opcijai!",
+            "noPermissionsLimitOptionUser": "Jūs nevarat izveidot biļeti, jo esat sasniedzis maksimālo biļešu skaitu šai opcijai!",
+            "unknownTicket": "Mēģiniet vēlreiz izmantot šo komandu derīgā biļetē!",
+            "deprecatedTicket": "Pašreizējais kanāls nav derīga biļete! Tas varētu būt biļete no vecas Open Ticket versijas!",
+            "notInGuild": "Šis {0} nedarbojas DM! Lūdzu, mēģiniet vēlreiz serverī!",
+            "channelRename": "Discord ierobežojumu dēļ bots pašlaik nevar pārdēvēt kanālu. Kanāls tiks automātiski pārdēvēts 10 minūšu laikā, ja bots netiks restartēts.",
+            "channelRenameSource": "Šīs kļūdas avots ir: {0}",
+            "busy": "Nevar izmantot šo {0}!\nBiļete pašlaik tiek apstrādāta ar botu.\n\nLūdzu, mēģiniet vēlreiz pēc dažām sekundēm!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Vērtība neatbilst šablonam!",
+            "stringMinLength": "Vērtībai jābūt vismaz {0} rakstzīmēm!",
+            "stringMaxLength": "Vērtībai jābūt ne vairāk kā {0} rakstzīmēm!",
+            "numberInvalid": "Nederīgs skaitlis!",
+            "numberMin": "Skaitlim jābūt vismaz {0}!",
+            "numberMax": "Skaitlim jābūt ne vairāk kā {0}!",
+            "numberDecimal": "Skaitlis nedrīkst būt decimāldaļa!",
+            "numberNegative": "Skaitlis nedrīkst būt negatīvs!",
+            "numberPositive": "Skaitlis nedrīkst būt pozitīvs!",
+            "numberZero": "Skaitlis nedrīkst būt nulle!",
+            "channelNotFound": "Nevar atrast kanālu!",
+            "userNotFound": "Nevar atrast lietotāju!",
+            "roleNotFound": "Nevar atrast lomu!",
+            "memberNotFound": "Nevar atrast lietotāju!",
+            "mentionableNotFound": "Nevar atrast lietotāju vai lomu!",
+            "channelType": "Nederīgs kanāla tips!",
+            "notInGuild": "Šai opcijai jābūt serverī!"
+        },
+        "permissions": {
+            "developer": "Jums jābūt bota izstrādātājam.",
+            "owner": "Jums jābūt servera īpašniekam.",
+            "admin": "Jums jābūt servera administratoram.",
+            "moderator": "Jums jābūt moderatoram.",
+            "support": "Jums jābūt atbalsta komandā.",
+            "member": "Jums jābūt dalībniekam.",
+            "discord-administrator": "Jums jābūt `ADMINISTRATOR` atļaujai."
+        },
+        "actionInvalid": {
+            "close": "Biļete jau ir aizvērta!",
+            "reopen": "Biļete vēl nav aizvērta!",
+            "claim": "Biļete jau ir pieprasīta!",
+            "unclaim": "Biļete vēl nav pieprasīta!",
+            "pin": "Biļete jau ir piesprausta!",
+            "unpin": "Biļete nav piesprausta!",
+            "add": "Šis lietotājs jau var piekļūt biļetei!",
+            "remove": "Nevar noņemt šo lietotāju no biļetes!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Biļete",
+            "tickets": "Biļetes",
+            "reason": "Iemesls",
+            "creator": "Izveidotājs",
+            "remaining": "Atlikušais laiks",
+            "added": "Pievienots",
+            "removed": "Noņemts",
+            "filter": "Filtrs",
+            "claimedBy": "Pieprasījis {0}",
+            "method": "Metode",
+            "type": "Tips",
+            "blacklisted": "Melnajā sarakstā",
+            "panel": "Panelis",
+            "command": "Komanda",
+            "system": "Sistēma",
+            "true": "Patiess",
+            "false": "Nepatiess",
+            "syntax": "Sintakse",
+            "originalName": "Sākotnējais nosaukums",
+            "newName": "Jaunais nosaukums",
+            "until": "Līdz",
+            "validOptions": "Derīgas opcijas",
+            "validPanels": "Derīgi paneļi",
+            "autoclose": "Automātiskā aizvēršana",
+            "autodelete": "Automātiskā dzēšana",
+            "startupDate": "Startēšanas datums",
+            "version": "Versija",
+            "name": "Nosaukums",
+            "role": "Loma",
+            "status": "Statuss",
+            "claimed": "Pieprasīts",
+            "pinned": "Piesprausts",
+            "creationDate": "Izveidošanas datums"
+        },
+        "lowercase": {
+            "text": "teksts",
+            "html": "html",
+            "command": "komanda",
+            "modal": "modāls",
+            "button": "poga",
+            "dropdown": "izvēlne",
+            "method": "metode"
+        }
+    },
+    "commands": {
+        "reason": "Norādiet izvēles iemeslu, kas būs redzams žurnālos.",
+        "help": "Iegūstiet visu pieejamo komandu sarakstu.",
+        "panel": "Izveidojiet ziņojumu ar izvēlni vai pogām (biļešu izveidei).",
+        "panelId": "Paneļa identifikators, kuru vēlaties izveidot.",
+        "panelAutoUpdate": "Vai vēlaties, lai šis panelis automātiski atjauninātos, kad tas tiek rediģēts?",
+        "ticket": "Nekavējoties izveidojiet biļeti.",
+        "ticketId": "Biļetes identifikators, kuru vēlaties izveidot.",
+        "close": "Aizveriet biļeti.",
+        "delete": "Dzēsiet biļeti.",
+        "deleteNoTranscript": "Dzēsiet šo biļeti, neizveidojot transkriptu.",
+        "reopen": "Atveriet biļeti no jauna.",
+        "claim": "Pieprasiet biļeti.",
+        "claimUser": "Pieprasiet šo biļeti kādam citam, nevis sev.",
+        "unclaim": "Atceliet biļetes pieprasījumu.",
+        "pin": "Piespraudiet biļeti.",
+        "unpin": "Atspraudiet biļeti.",
+        "move": "Pārvietojiet biļeti.",
+        "moveId": "Opcijas identifikators, uz kuru vēlaties pārvietot.",
+        "rename": "Pārdēvējiet biļeti.",
+        "renameName": "Jaunais nosaukums šai biļetei.",
+        "add": "Pievienojiet lietotāju biļetei.",
+        "addUser": "Lietotājs, kuru pievienot.",
+        "remove": "Noņemiet lietotāju no biļetes.",
+        "removeUser": "Lietotājs, kuru noņemt.",
+        "blacklist": "Pārvaldiet biļešu melno sarakstu.",
+        "blacklistView": "Skatiet pašreizējā melnā saraksta sarakstu.",
+        "blacklistAdd": "Pievienojiet lietotāju melnajam sarakstam.",
+        "blacklistRemove": "Noņemiet lietotāju no melnā saraksta.",
+        "blacklistGet": "Iegūstiet informāciju par melnajā sarakstā esošu lietotāju.",
+        "blacklistGetUser": "Lietotājs, par kuru iegūt informāciju.",
+        "stats": "Skatiet statistiku no bota, dalībnieka vai biļetes.",
+        "statsReset": "Atiestatiet visu bota statistiku (un sāciet skaitīt no nulles).",
+        "statsGlobal": "Skatiet globālo statistiku.",
+        "statsUser": "Skatiet lietotāja statistiku serverī.",
+        "statsUserUser": "Lietotājs, kuru skatīt.",
+        "statsTicket": "Skatiet biļetes statistiku serverī.",
+        "statsTicketTicket": "Biļete, kuru skatīt.",
+        "clear": "Dzēsiet vairākas biļetes vienlaikus.",
+        "clearFilter": "Filtrs biļešu dzēšanai.",
+        "clearFilters": {
+            "all": "Visas",
+            "open": "Atvērtas",
+            "close": "Aizvērtas",
+            "claim": "Pieprasītas",
+            "unclaim": "Nepieprasītas",
+            "pin": "Piespraustas",
+            "unpin": "Atspraustas",
+            "autoclose": "Automātiski aizvērtas"
+        },
+        "autoclose": "Pārvaldiet automātisko aizvēršanu biļetē.",
+        "autocloseDisable": "Atspējojiet automātisko aizvēršanu šai biļetei.",
+        "autocloseEnable": "Ieslēdziet automātisko aizvēršanu šai biļetei.",
+        "autocloseEnableTime": "Stundu skaits, cik ilgi biļetei jābūt neaktīvai, lai to aizvērtu.",
+        "autodelete": "Pārvaldiet automātisko dzēšanu biļetē.",
+        "autodeleteDisable": "Atspējojiet automātisko dzēšanu šai biļetei.",
+        "autodeleteEnable": "Ieslēdziet automātisko dzēšanu šai biļetei.",
+        "autodeleteEnableTime": "Dienu skaits, cik ilgi biļetei jābūt neaktīvai, lai to dzēstu."
+    },
+    "helpMenu": {
+        "help": "Iegūstiet visu pieejamo komandu sarakstu.",
+        "ticket": "Nekavējoties izveidojiet biļeti.",
+        "close": "Aizveriet biļeti, tas atspējo rakstīšanu šajā kanālā.",
+        "delete": "Dzēsiet biļeti, tas izveido transkriptu, ja ir iespējots.",
+        "reopen": "Atveriet biļeti no jauna, tas atkal iespējo rakstīšanu šajā kanālā.",
+        "pin": "Piespraudiet biļeti. Tas pārvietos biļeti uz augšu un pievienos '📌' emocijzīmi nosaukumam.",
+        "unpin": "Atspraudiet biļeti. Biļete paliks savā pozīcijā, bet zaudēs '📌' emocijzīmi.",
+        "move": "Pārvietojiet biļeti. Tas mainīs šīs biļetes tipu.",
+        "rename": "Pārdēvējiet biļeti. Tas mainīs šīs biļetes kanāla nosaukumu.",
+        "claim": "Pieprasiet biļeti. Ar to jūs varat informēt savu komandu, ka jūs apstrādājat šo biļeti.",
+        "unclaim": "Atceliet biļetes pieprasījumu. Ar to jūs varat informēt savu komandu, ka šī biļete atkal ir brīva.",
+        "add": "Pievienojiet lietotāju biļetei. Tas ļaus lietotājam lasīt un rakstīt šajā biļetē.",
+        "remove": "Noņemiet lietotāju no biļetes. Tas atņems lietotājam iespēju lasīt un rakstīt šajā biļetē.",
+        "panel": "Izveidojiet ziņojumu ar izvēlni vai pogām (biļešu izveidei).",
+        "blacklistView": "Skatiet pašreizējā melnā saraksta sarakstu.",
+        "blacklistAdd": "Pievienojiet lietotāju melnajam sarakstam.",
+        "blacklistRemove": "Noņemiet lietotāju no melnā saraksta.",
+        "blacklistGet": "Iegūstiet informāciju par melnajā sarakstā esošu lietotāju.",
+        "statsGlobal": "Skatiet globālo statistiku.",
+        "statsTicket": "Skatiet biļetes statistiku serverī.",
+        "statsUser": "Skatiet lietotāja statistiku serverī.",
+        "statsReset": "Atiestatiet visu bota statistiku (un sāciet skaitīt no nulles).",
+        "autocloseDisable": "Atspējojiet automātisko aizvēršanu šai biļetei.",
+        "autocloseEnable": "Ieslēdziet automātisko aizvēršanu šai biļetei.",
+        "autodeleteDisable": "Atspējojiet automātisko dzēšanu šai biļetei.",
+        "autodeleteEnable": "Ieslēdziet automātisko dzēšanu šai biļetei."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Globālā statistika",
+            "system": "Sistēmas statistika",
+            "user": "Lietotāja statistika",
+            "ticket": "Biļešu statistika",
+            "participants": "Dalībnieki"
+        },
+        "properties": {
+            "ticketsCreated": "Izveidotās biļetes",
+            "ticketsClosed": "Aizvērtās biļetes",
+            "ticketsDeleted": "Dzēstās biļetes",
+            "ticketsReopened": "Atkal atvērtās biļetes",
+            "ticketsAutoclosed": "Automātiski aizvērtās biļetes",
+            "ticketsClaimed": "Pieprasītās biļetes",
+            "ticketsPinned": "Piespraustās biļetes",
+            "ticketsMoved": "Pārvietotās biļetes",
+            "usersBlacklisted": "Melnajā sarakstā esošie lietotāji",
+            "transcriptsCreated": "Izveidotie transkripti"
+        }
+    }
+}
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["TsgIndrius"],
        "lastedited":"26/01/2025",
        "language":"Lithuanian",
@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.4",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Norwegian",
+        "automated": false
+    },
+    "checker": {
+        "system": {
+            "typeError": "[FEIL]",
+            "headerOpenTicket": "ÅPNE SAK",
+            "typeWarning": "[ADVARSEL]",
+            "typeInfo": "[INFO]",
+            "headerConfigChecker": "KONFIGURASJONSSJEKKER",
+            "headerDescription": "sjekk etter feil i konfigurasjonen din!",
+            "footerError": "boten starter ikke før alle {0} er fikset!",
+            "footerWarning": "det anbefales å fikse alle {0} før oppstart!",
+            "footerSupport": "STØTTE: {0} - DOKUMENTASJON: {1}",
+            "compactInformation": "bruk {0} for mer informasjon!",
+            "dataPath": "sti",
+            "dataDocs": "dokumentasjon",
+            "dataMessages": "melding"
+        },
+        "messages": {
+            "stringTooShort": "Denne strengen kan ikke være kortere enn {0} tegn!",
+            "stringTooLong": "Denne strengen kan ikke være lengre enn {0} tegn!",
+            "stringLengthInvalid": "Denne strengen skal være {0} tegn lang!",
+            "stringStartsWith": "Denne strengen skal starte med {0}!",
+            "stringEndsWith": "Denne strengen skal slutte med {0}!",
+            "stringContains": "Denne strengen skal inneholde {0}!",
+            "stringChoices": "Denne strengen kan kun være en av følgende verdier: {0}!",
+            "stringRegex": "Denne strengen er ugyldig!",
+  
+            "numberTooShort": "Dette tallet kan ikke være kortere enn {0} tegn!",
+            "numberTooLong": "Dette tallet kan ikke være lengre enn {0} tegn!",
+            "numberLengthInvalid": "Dette tallet skal være {0} tegn langt!",
+            "numberTooSmall": "Dette tallet skal være minst {0}!",
+            "numberTooLarge": "Dette tallet skal være høyst {0}!",
+            "numberNotEqual": "Dette tallet skal være {0}!",
+            "numberStep": "Dette tallet skal være et multiplum av {0}!",
+            "numberStepOffset": "Dette tallet skal være et multiplum av {0}, startende med {1}!",
+            "numberStartsWith": "Dette tallet skal starte med {0}!",
+            "numberEndsWith": "Dette tallet skal slutte med {0}!",
+            "numberContains": "Dette tallet skal inneholde {0}!",
+            "numberChoices": "Dette tallet kan kun være en av følgende verdier: {0}!",
+            "numberFloat": "Dette tallet kan ikke være et desimaltall!",
+            "numberNegative": "Dette tallet kan ikke være negativt!",
+            "numberPositive": "Dette tallet kan ikke være positivt!",
+            "numberZero": "Dette tallet kan ikke være null!",
+  
+            "booleanTrue": "Denne boolske verdien kan ikke være sann!",
+            "booleanFalse": "Denne boolske verdien kan ikke være usann!",
+
+            "arrayEmptyDisabled": "Denne listen kan ikke være tom!",
+            "arrayEmptyRequired": "Denne listen skal være tom!",
+            "arrayTooShort": "Denne listen skal ha en lengde på minst {0}!",
+            "arrayTooLong": "Denne listen skal ha en lengde på høyst {0}!",
+            "arrayLengthInvalid": "Denne listen skal ha en lengde på {0}!",
+            "arrayInvalidTypes": "Denne listen kan kun inneholde følgende typer: {0}!",
+            "arrayDouble": "Denne listen tillater ikke samme verdi to ganger!",
+  
+            "discordInvalidId": "Dette er en ugyldig Discord {0} ID!",
+            "discordInvalidIdOptions": "Dette er en ugyldig Discord {0} ID! Du kan også bruke en av disse: {1}!",
+            "discordInvalidToken": "Dette er et ugyldig Discord-token (syntaktisk)!",
+            "colorInvalid": "Dette er en ugyldig heksadesimal farge!",
+            "emojiTooShort": "Denne strengen skal ha minst {0} emojier!",
+            "emojiTooLong": "Denne strengen skal ha høyst {0} emojier!",
+            "emojiCustom": "Denne emojien kan ikke være en tilpasset Discord-emoji!",
+            "emojiInvalid": "Dette er en ugyldig emoji!",
+            "urlInvalid": "Denne URL-en er ugyldig!",
+            "urlInvalidHttp": "Denne URL-en kan kun bruke https://-protokollen!",
+            "urlInvalidProtocol": "Denne URL-en kan kun bruke http://- og https://-protokollene!",
+            "urlInvalidHostname": "Denne URL-en har et ikke-tillatt vertsnavn!",
+            "urlInvalidExtension": "Denne URL-en har en ugyldig filtype! Velg mellom: {0}!",
+            "urlInvalidPath": "Denne URL-en har en ugyldig sti!",
+            "idNotUnique": "Denne ID-en er ikke unik, bruk en annen ID i stedet!",
+            "idNonExistent": "ID-en {0} finnes ikke!",
+
+            "invalidType": "Denne egenskapen skal være av typen: {0}!",
+            "propertyMissing": "Egenskapen {0} mangler i dette objektet!",
+            "propertyOptional": "Egenskapen {0} er valgfri i dette objektet!",
+            "objectDisabled": "Dette objektet er deaktivert, aktiver det ved å bruke {0}!",
+            "nullInvalid": "Denne egenskapen kan ikke være null!",
+            "switchInvalidType": "Dette skal være en av følgende typer: {0}!",
+            "objectSwitchInvalid": "Dette objektet skal være en av følgende typer: {0}!",
+  
+            "invalidLanguage": "Dette er et ugyldig språk!",
+            "invalidButton": "Denne knappen skal ha minst en {0} eller {1}!",
+            "unusedOption": "Alternativet {0} brukes ikke noe sted!",
+            "unusedQuestion": "Spørsmålet {0} brukes ikke noe sted!",
+            "dropdownOption": "Et panel med nedtrekksmeny aktivert kan kun inneholde alternativer av typen 'sak'!"
+        }
+    },
+        "actions": {
+            "buttons": {
+                "create": "Opprett Sak",
+                "close": "Lukk Sak",
+                "delete": "Slett Sak",
+                "reopen": "Gjenåpne Sak",
+                "claim": "Ta Sak",
+                "unclaim": "Frigi Sak",
+                "pin": "Fest Sak",
+                "unpin": "Løsne Sak",
+                "clear": "Slett Saker",
+                "helpSwitchSlash": "Vis Skråstrekskommandoer",
+                "helpSwitchText": "Vis Tekstkommandoer",
+                "helpPage": "Side {0}",
+                "withReason": "Med Årsak",
+                "withoutTranscript": "Uten Utskrift"
+            },
+            "titles": {
+                "created": "Sak Opprettet",
+                "close": "Sak Lukket",
+                "delete": "Sak Slettet",
+                "reopen": "Sak Gjenåpnet",
+                "claim": "Sak Tatt",
+                "unclaim": "Sak Frigitt",
+                "pin": "Sak Festet",
+                "unpin": "Sak Løsnet",
+                "rename": "Sak Omdøpt",
+                "move": "Sak Flyttet",
+                "add": "Bruker Lagt Til Sak",
+                "remove": "Bruker Fjernet Fra Sak",
+    
+                "help": "Tilgjengelige Kommandoer",
+                "statsReset": "Tilbakestill Statistikk",
+                "blacklistAdd": "Bruker Svartelistet",
+                "blacklistRemove": "Bruker Fjernet Fra Svarteliste",
+                "blacklistGet": "Svartelistet Bruker",
+                "blacklistView": "Gjeldende Svarteliste",
+                "blacklistAddDm": "Lagt Til Svarteliste",
+                "blacklistRemoveDm": "Fjernet Fra Svarteliste",
+                "clear": "Saker Slettet",
+                "roles": "Roller Oppdatert",
+    
+                "autoclose": "Sak Autolukket",
+                "autocloseEnabled": "Autolukking Aktivert",
+                "autocloseDisabled": "Autolukking Deaktivert",
+                "autodelete": "Sak Autoslettet",
+                "autodeleteEnabled": "Autosletting Aktivert",
+                "autodeleteDisabled": "Autosletting Deaktivert"
+            },
+            "descriptions": {
+                "create": "Din sak er blitt opprettet. Klikk på knappen nedenfor for å få tilgang til den!",
+                "close": "Saken er blitt lukket vellykket!",
+                "delete": "Saken er blitt slettet vellykket!",
+                "reopen": "Saken er blitt gjenåpnet vellykket!",
+                "claim": "Saken er blitt tatt vellykket!",
+                "unclaim": "Saken er blitt frigitt vellykket!",
+                "pin": "Saken er blitt festet vellykket!",
+                "unpin": "Saken er blitt løsnet vellykket!",
+                "rename": "Saken er blitt omdøpt til {0} vellykket!",
+                "move": "Saken er blitt flyttet til {0} vellykket!",
+                "add": "{0} er blitt lagt til saken vellykket!",
+                "remove": "{0} er blitt fjernet fra saken vellykket!",
+    
+                "helpExplanation": "`<navn>` => påkrevd parameter\n`[navn]` => valgfri parameter",
+                "statsReset": "Botens statistikk er blitt tilbakestilt vellykket!",
+                "statsError": "Kan ikke vise saksstatistikk!\n{0} er ikke en sak!",
+                "blacklistAdd": "{0} er blitt svartelistet vellykket!",
+                "blacklistRemove": "{0} er blitt fjernet fra svartelisten vellykket!",
+                "blacklistGetSuccess": "{0} er for øyeblikket svartelistet!",
+                "blacklistGetEmpty": "{0} er for øyeblikket ikke svartelistet!",
+                "blacklistViewEmpty": "Ingen er svartelistet ennå!",
+                "blacklistViewTip": "Bruk \"/blacklist add\" for å svarteliste en bruker!",
+                "clearVerify": "Er du sikker på at du vil slette flere saker?\nDenne handlingen kan ikke angres!",
+                "clearReady": "{0} saker er blitt slettet vellykket!",
+                "rolesEmpty": "Ingen roller er blitt oppdatert!",
+    
+                "autocloseLeave": "Denne saken er blitt autolukket fordi oppretteren forlot serveren!",
+                "autocloseTimeout": "Denne saken er blitt autolukket fordi den har vært inaktiv i mer enn `{0}t`!",
+                "autodeleteLeave": "Denne saken er blitt autoslettet fordi oppretteren forlot serveren!",
+                "autodeleteTimeout": "Denne saken er blitt autoslettet fordi den har vært inaktiv i mer enn `{0} dager`!",
+                "autocloseEnabled": "Autolukking er blitt aktivert i denne saken!\nDen vil bli lukket når den er inaktiv i mer enn `{0}t`!",
+                "autocloseDisabled": "Autolukking er blitt deaktivert i denne saken!\nDen vil ikke lenger bli lukket automatisk!",
+                "autodeleteEnabled": "Autosletting er blitt aktivert i denne saken!\nDen vil bli slettet når den er inaktiv i mer enn `{0} dager`!",
+                "autodeleteDisabled": "Autosletting er blitt deaktivert i denne saken!\nDen vil ikke lenger bli slettet automatisk!",
+    
+                "ticketMessageLimit": "Du kan kun opprette {0} sak(er) om gangen!",
+                "ticketMessageAutoclose": "Denne saken vil bli autolukket når den er inaktiv i {0}t!",
+                "ticketMessageAutodelete": "Denne saken vil bli autoslettet når den er inaktiv i {0} dager!",
+                "panelReady": "Du finner panelet nedenfor!\nDenne meldingen kan nå slettes!"
+            },
+            "modal": {
+                "closePlaceholder": "Hvorfor lukket du denne saken?",
+                "deletePlaceholder": "Hvorfor slettet du denne saken?",
+                "reopenPlaceholder": "Hvorfor gjenåpnet du denne saken?",
+                "claimPlaceholder": "Hvorfor tok du denne saken?",
+                "unclaimPlaceholder": "Hvorfor frigjorde du denne saken?",
+                "pinPlaceholder": "Hvorfor festet du denne saken?",
+                "unpinPlaceholder": "Hvorfor løsnet du denne saken?"
+            },
+            "logs": {
+                "createLog": "En ny sak er blitt opprettet av {0}!",
+                "closeLog": "Denne saken er blitt lukket av {0}!",
+                "closeDm": "Din sak er blitt lukket på vår server!",
+                "deleteLog": "Denne saken er blitt slettet av {0}!",
+                "deleteDm": "Din sak er blitt slettet på vår server!",
+                "reopenLog": "Denne saken er blitt gjenåpnet av {0}!",
+                "reopenDm": "Din sak er blitt gjenåpnet på vår server!",
+                "claimLog": "Denne saken er blitt tatt av {0}!",
+                "claimDm": "Din sak er blitt tatt på vår server!",
+                "unclaimLog": "Denne saken er blitt frigitt av {0}!",
+                "unclaimDm": "Din sak er blitt frigitt på vår server!",
+                "pinLog": "Denne saken er blitt festet av {0}!",
+                "pinDm": "Din sak er blitt festet på vår server!",
+                "unpinLog": "Denne saken er blitt løsnet av {0}!",
+                "unpinDm": "Din sak er blitt løsnet på vår server!",
+                "renameLog": "Denne saken er blitt omdøpt til {0} av {1}!",
+                "renameDm": "Din sak er blitt omdøpt til {0} på vår server!",
+                "moveLog": "Denne saken er blitt flyttet til {0} av {1}!",
+                "moveDm": "Din sak er blitt flyttet til {0} på vår server!",
+                "addLog": "{0} er blitt lagt til denne saken av {1}!",
+                "addDm": "{0} er blitt lagt til din sak på vår server!",
+                "removeLog": "{0} er blitt fjernet fra denne saken av {1}!",
+                "removeDm": "{0} er blitt fjernet fra din sak på vår server!",
+    
+                "blacklistAddLog": "{0} er blitt svartelistet av {1}!",
+                "blacklistRemoveLog": "{0} er blitt fjernet fra svartelisten av {1}!",
+                "blacklistAddDm": "Du er blitt svartelistet på vår server!\nFra nå av kan du ikke opprette en sak!",
+                "blacklistRemoveDm": "Du er blitt fjernet fra svartelisten på vår server!\nNå kan du opprette saker igjen!",
+                "clearLog": "{0} saker er blitt slettet av {1}!"
+        }
+      },
+      "transcripts": {
+        "success": {
+            "visit": "Besøk Utskrift",
+            "ready": "Utskrift Opprettet",
+            "textFileDescription": "Dette er tekstutskriften av en slettet sak!",
+            "htmlProgress": "Vennligst vent mens denne HTML-utskriften blir behandlet...",
+
+            "createdChannel": "En ny {0} utskrift er blitt opprettet på serveren!",
+            "createdCreator": "En ny {0} utskrift er blitt opprettet for en av dine saker!",
+            "createdParticipant": "En ny {0} utskrift er blitt opprettet i en av sakene du deltok i!",
+            "createdActiveAdmin": "En ny {0} utskrift er blitt opprettet i en av sakene du deltok i som admin!",
+            "createdEveryAdmin": "En ny {0} utskrift er blitt opprettet i en av sakene du var admin i!",
+            "createdOther": "En ny {0} utskrift er blitt opprettet!"
+        },
+        "errors": {
+            "retry": "Prøv Igjen",
+            "continue": "Slett Uten Utskrift",
+            "backup": "Opprett Sikkerhetskopiutskrift",
+            "error": "Noe gikk galt under forsøket på å opprette utskriften.\nHva vil du gjøre?\n\nDenne saken vil ikke bli slettet før du klikker på en av disse knappene."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Intern Feil",
+            "optionMissing": "Kommandoalternativ Mangler",
+            "optionInvalid": "Ugyldig Kommandoalternativ",
+            "unknownCommand": "Ukjent Kommando",
+            "noPermissions": "Ingen Tillatelser",
+            "unknownTicket": "Ukjent Sak",
+            "deprecatedTicket": "Utdatert Sak",
+            "unknownOption": "Ukjent Alternativ",
+            "unknownPanel": "Ukjent Panel",
+            "notInGuild": "Ikke På Server",
+            "channelRename": "Kan Ikke Omdøpe Kanal",
+            "busy": "Saken Er Opptatt"
+        },
+        "descriptions": {
+            "askForInfo": "Kontakt eieren av denne boten for mer informasjon!",
+            "askForInfoResolve": "Kontakt eieren av denne boten hvis problemet ikke løser seg etter noen forsøk!",
+            "internalError": "Kunne ikke svare på denne {0} på grunn av en intern feil!",
+            "optionMissing": "En påkrevd parameter mangler i denne kommandoen!",
+            "optionInvalid": "En parameter i denne kommandoen er ugyldig!",
+            "optionInvalidChoose": "Velg mellom",
+            "unknownCommand": "Prøv å besøke hjelpmenyen for mer informasjon!",
+            "noPermissions": "Du har ikke tillatelse til å bruke denne {0}!",
+            "noPermissionsList": "Påkrevde tillatelser: (en av dem)",
+            "noPermissionsCooldown": "Du har ikke tillatelse til å bruke denne {0} fordi du har en nedkjølingsperiode!",
+            "noPermissionsBlacklist": "Du har ikke tillatelse til å bruke denne {0} fordi du er svartelistet!",
+            "noPermissionsLimitGlobal": "Du har ikke tillatelse til å opprette en sak fordi serveren har nådd maksgrensen for saker!",
+            "noPermissionsLimitGlobalUser": "Du har ikke tillatelse til å opprette en sak fordi du har nådd maksgrensen for saker!",
+            "noPermissionsLimitOption": "Du har ikke tillatelse til å opprette en sak fordi serveren har nådd maksgrensen for dette alternativet!",
+            "noPermissionsLimitOptionUser": "Du har ikke tillatelse til å opprette en sak fordi du har nådd maksgrensen for dette alternativet!",
+            "unknownTicket": "Prøv denne kommandoen igjen i en gyldig sak!",
+            "deprecatedTicket": "Den nåværende kanalen er ikke en gyldig sak! Den kan ha vært en sak fra en eldre versjon av Open Ticket!",
+            "notInGuild": "Denne {0} fungerer ikke i DM! Prøv igjen på en server!",
+            "channelRename": "På grunn av Discords hastighetsbegrensninger er det for øyeblikket umulig for boten å omdøpe kanalen. Kanalen vil automatisk bli omdøpt innen 10 minutter hvis boten ikke startes på nytt.",
+            "channelRenameSource": "Kilden til denne feilen er: {0}",
+            "busy": "Kan ikke bruke denne {0}!\nSaken behandles for øyeblikket av boten.\n\nPrøv igjen om noen sekunder!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Verdien samsvarer ikke med mønsteret!",
+            "stringMinLength": "Verdien skal være minst {0} tegn!",
+            "stringMaxLength": "Verdien skal være høyst {0} tegn!",
+            "numberInvalid": "Ugyldig tall!",
+            "numberMin": "Tallet skal være minst {0}!",
+            "numberMax": "Tallet skal være høyst {0}!",
+            "numberDecimal": "Tallet kan ikke være et desimaltall!",
+            "numberNegative": "Tallet kan ikke være negativt!",
+            "numberPositive": "Tallet kan ikke være positivt!",
+            "numberZero": "Tallet kan ikke være null!",
+            "channelNotFound": "Kan ikke finne kanalen!",
+            "userNotFound": "Kan ikke finne brukeren!",
+            "roleNotFound": "Kan ikke finne rollen!",
+            "memberNotFound": "Kan ikke finne brukeren!",
+            "mentionableNotFound": "Kan ikke finne brukeren eller rollen!",
+            "channelType": "Ugyldig kanaltype!",
+            "notInGuild": "Dette alternativet krever at du er på en server!"
+        },
+        "permissions": {
+            "developer": "Du må være utvikleren av boten.",
+            "owner": "Du må være servereieren.",
+            "admin": "Du må være serveradministrator.",
+            "moderator": "Du må være moderator.",
+            "support": "Du må være en del av støtteteamet.",
+            "member": "Du må være medlem.",
+            "discord-administrator": "Du må ha `ADMINISTRATOR`-tillatelsen."
+        },
+        "actionInvalid": {
+            "close": "Saken er allerede lukket!",
+            "reopen": "Saken er ikke lukket ennå!",
+            "claim": "Saken er allerede tatt!",
+            "unclaim": "Saken er ikke tatt ennå!",
+            "pin": "Saken er allerede festet!",
+            "unpin": "Saken er ikke festet ennå!",
+            "add": "Denne brukeren har allerede tilgang til saken!",
+            "remove": "Kan ikke fjerne denne brukeren fra saken!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Sak",
+            "tickets": "Saker",
+            "reason": "Årsak",
+            "creator": "Oppretter",
+            "remaining": "Tid Igjen",
+            "added": "Lagt Til",
+            "removed": "Fjernet",
+            "filter": "Filter",
+            "claimedBy": "Tatt Av {0}",
+            "method": "Metode",
+            "type": "Type",
+            "blacklisted": "Svartelistet",
+            "panel": "Panel",
+            "command": "Kommando",
+            "system": "System",
+            "true": "Sann",
+            "false": "Usann",
+            "syntax": "Syntaks",
+            "originalName": "Opprinnelig Navn",
+            "newName": "Nytt Navn",
+            "until": "Til",
+            "validOptions": "Gyldige Alternativer",
+            "validPanels": "Gyldige Paneler",
+            "autoclose": "Autolukking",
+            "autodelete": "Autosletting",
+            "startupDate": "Oppstartsdato",
+            "version": "Versjon",
+            "name": "Navn",
+            "role": "Rolle",
+            "status": "Status",
+            "claimed": "Tatt",
+            "pinned": "Festet",
+            "creationDate": "Opprettelsesdato"
+        },
+        "lowercase": {
+            "text": "tekst",
+            "html": "html",
+            "command": "kommando",
+            "modal": "modal",
+            "button": "knapp",
+            "dropdown": "nedtrekksmeny",
+            "method": "metode"
+        }
+    },
+    "commands": {
+        "reason": "Angi en valgfri årsak som vil være synlig i loggene.",
+        "help": "Få en liste over alle tilgjengelige kommandoer.",
+        "panel": "Opprett en melding med en nedtrekksmeny eller knapper (for sakopprettelse).",
+        "panelId": "Identifikatoren for panelet du vil opprette.",
+        "panelAutoUpdate": "Ønsker du at dette panelet skal oppdatere seg automatisk når det redigeres?",
+        "ticket": "Opprett en sak med det samme.",
+        "ticketId": "Identifikatoren for saken du vil opprette.",
+        "close": "Lukk en sak.",
+        "delete": "Slett en sak.",
+        "deleteNoTranscript": "Slett denne saken uten å opprette en utskrift.",
+        "reopen": "Gjenåpne en sak.",
+        "claim": "Ta en sak.",
+        "claimUser": "Ta denne saken for en annen bruker i stedet for deg selv.",
+        "unclaim": "Frigi en sak.",
+        "pin": "Fest en sak.",
+        "unpin": "Løsne en sak.",
+        "move": "Flytt en sak.",
+        "moveId": "Identifikatoren for alternativet du vil flytte til.",
+        "rename": "Omdøp en sak.",
+        "renameName": "Det nye navnet på denne saken.",
+        "add": "Legg til en bruker i en sak.",
+        "addUser": "Brukeren som skal legges til.",
+        "remove": "Fjern en bruker fra en sak.",
+        "removeUser": "Brukeren som skal fjernes.",
+        "blacklist": "Administrer svartelisten for saker.",
+        "blacklistView": "Vis en liste over gjeldende svarteliste.",
+        "blacklistAdd": "Legg til en bruker på svartelisten.",
+        "blacklistRemove": "Fjern en bruker fra svartelisten.",
+        "blacklistGet": "Hent detaljer om en svartelistet bruker.",
+        "blacklistGetUser": "Brukeren å hente detaljer fra.",
+        "stats": "Vis statistikk fra boten, en bruker eller en sak.",
+        "statsReset": "Tilbakestill all statistikk for boten (og start tellingen fra null).",
+        "statsGlobal": "Vis global statistikk.",
+        "statsUser": "Vis statistikk fra en bruker på serveren.",
+        "statsUserUser": "Brukeren som skal vises.",
+        "statsTicket": "Vis statistikk for en sak på serveren.",
+        "statsTicketTicket": "Saken som skal vises.",
+        "clear": "Slett flere saker samtidig.",
+        "clearFilter": "Filteret for å slette saker.",
+        "clearFilters": {
+            "all": "Alle",
+            "open": "Åpne",
+            "close": "Lukkede",
+            "claim": "Tatte",
+            "unclaim": "Frigitte",
+            "pin": "Festede",
+            "unpin": "Løsnede",
+            "autoclose": "Autolukkede"
+        },
+        "autoclose": "Administrer autolukking i en sak.",
+        "autocloseDisable": "Deaktiver autolukking i denne saken.",
+        "autocloseEnable": "Aktiver autolukking i denne saken.",
+        "autocloseEnableTime": "Antall timer denne saken må være inaktiv før den lukkes.",
+        "autodelete": "Administrer autosletting i en sak.",
+        "autodeleteDisable": "Deaktiver autosletting i denne saken.",
+        "autodeleteEnable": "Aktiver autosletting i denne saken.",
+        "autodeleteEnableTime": "Antall dager denne saken må være inaktiv før den slettes."
+    },
+    "helpMenu": {
+        "help": "Få en liste over alle tilgjengelige kommandoer.",
+        "ticket": "Opprett en sak med det samme.",
+        "close": "Lukk en sak, dette deaktiverer skriving i kanalen.",
+        "delete": "Slett en sak, dette oppretter en utskrift når det er aktivert.",
+        "reopen": "Gjenåpne en sak, dette aktiverer skriving i kanalen igjen.",
+        "pin": "Fest en sak. Dette flytter saken til toppen og legger til en '📌' emoji i navnet.",
+        "unpin": "Løsne en sak. Saken blir værende på plass, men mister '📌' emojien.",
+        "move": "Flytt en sak. Dette endrer typen på saken.",
+        "rename": "Omdøp en sak. Dette endrer kanalnavnet på saken.",
+        "claim": "Ta en sak. Dette lar teamet ditt vite at du håndterer saken.",
+        "unclaim": "Frigi en sak. Dette lar teamet ditt vite at saken er ledig igjen.",
+        "add": "Legg til en bruker i en sak. Dette gir brukeren tilgang til å lese og skrive i saken.",
+        "remove": "Fjern en bruker fra en sak. Dette fjerner brukerens tilgang til å lese og skrive i saken.",
+        "panel": "Opprett en melding med en nedtrekksmeny eller knapper (for sakopprettelse).",
+        "blacklistView": "Vis en liste over gjeldende svarteliste.",
+        "blacklistAdd": "Legg til en bruker på svartelisten.",
+        "blacklistRemove": "Fjern en bruker fra svartelisten.",
+        "blacklistGet": "Hent detaljer om en svartelistet bruker.",
+        "statsGlobal": "Vis global statistikk.",
+        "statsTicket": "Vis statistikk for en sak på serveren.",
+        "statsUser": "Vis statistikk fra en bruker på serveren.",
+        "statsReset": "Tilbakestill all statistikk for boten (og start tellingen fra null).",
+        "autocloseDisable": "Deaktiver autolukking i denne saken.",
+        "autocloseEnable": "Aktiver autolukking i denne saken.",
+        "autodeleteDisable": "Deaktiver autosletting i denne saken.",
+        "autodeleteEnable": "Aktiver autosletting i denne saken."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Global Statistikk",
+            "system": "Systemstatistikk",
+            "user": "Brukerstatistikk",
+            "ticket": "Saksstatistikk",
+            "participants": "Deltakere"
+        },
+        "properties": {
+            "ticketsCreated": "Saker Opprettet",
+            "ticketsClosed": "Saker Lukket",
+            "ticketsDeleted": "Saker Slettet",
+            "ticketsReopened": "Saker Gjenåpnet",
+            "ticketsAutoclosed": "Saker Autolukket",
+            "ticketsClaimed": "Saker Tatt",
+            "ticketsPinned": "Saker Festet",
+            "ticketsMoved": "Saker Flyttet",
+            "usersBlacklisted": "Brukere Svartelistet",
+            "transcriptsCreated": "Utskrifter Opprettet"
+        }
+    }
+}
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["DanoGlez"],
        "lastedited":"28/01/2025",
        "language":"Polish",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["quiradon"],
        "lastedited":"20/08/2024",
        "language":"Portuguese",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["SankeDev"],
        "lastedited":"27/08/2024",
        "language":"Romanian",
@@ -0,0 +1,465 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.4",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Russian",
+        "automated": true
+    },
+    "checker": {
+        "system": {
+            "typeError": "[ОШИБКА]",
+            "headerOpenTicket": "ОТКРЫТЬ ТИКЕТ",
+            "typeWarning": "[ПРЕДУПРЕЖДЕНИЕ]",
+            "typeInfo": "[ИНФОРМАЦИЯ]",
+            "headerConfigChecker": "ПРОВЕРКА КОНФИГУРАЦИИ",
+            "headerDescription": "проверьте наличие ошибок в ваших конфигурационных файлах!",
+            "footerError": "бот не запустится, пока все {0} не будут исправлены!",
+            "footerWarning": "рекомендуется исправить все {0} перед запуском!",
+            "footerSupport": "ПОДДЕРЖКА: {0} - ДОКУМЕНТАЦИЯ: {1}",
+            "compactInformation": "используйте {0} для получения дополнительной информации!",
+            "dataPath": "путь",
+            "dataDocs": "документация",
+            "dataMessages": "сообщение"
+        },
+        "messages": {
+            "stringTooShort": "Эта строка не может быть короче {0} символов!",
+            "stringTooLong": "Эта строка не может быть длиннее {0} символов!",
+            "stringLengthInvalid": "Эта строка должна быть длиной {0} символов!",
+            "stringStartsWith": "Эта строка должна начинаться с {0}!",
+            "stringEndsWith": "Эта строка должна заканчиваться на {0}!",
+            "stringContains": "Эта строка должна содержать {0}!",
+            "stringChoices": "Эта строка может быть только одним из следующих значений: {0}!",
+            "stringRegex": "Эта строка недействительна!",
+            "numberTooShort": "Это число не может быть короче {0} символов!",
+            "numberTooLong": "Это число не может быть длиннее {0} символов!",
+            "numberLengthInvalid": "Это число должно быть длиной {0} символов!",
+            "numberTooSmall": "Это число должно быть не менее {0}!",
+            "numberTooLarge": "Это число должно быть не более {0}!",
+            "numberNotEqual": "Это число должно быть {0}!",
+            "numberStep": "Это число должно быть кратным {0}!",
+            "numberStepOffset": "Это число должно быть кратным {0}, начиная с {1}!",
+            "numberStartsWith": "Это число должно начинаться с {0}!",
+            "numberEndsWith": "Это число должно заканчиваться на {0}!",
+            "numberContains": "Это число должно содержать {0}!",
+            "numberChoices": "Это число может быть только одним из следующих значений: {0}!",
+            "numberFloat": "Это число не может быть десятичным!",
+            "numberNegative": "Это число не может быть отрицательным!",
+            "numberPositive": "Это число не может быть положительным!",
+            "numberZero": "Это число не может быть нулем!",
+            "booleanTrue": "Это булево значение не может быть истинным!",
+            "booleanFalse": "Это булево значение не может быть ложным!",
+            "arrayEmptyDisabled": "Этот массив не может быть пустым!",
+            "arrayEmptyRequired": "Этот массив должен быть пустым!",
+            "arrayTooShort": "Этот массив должен иметь длину не менее {0}!",
+            "arrayTooLong": "Этот массив должен иметь длину не более {0}!",
+            "arrayLengthInvalid": "Этот массив должен иметь длину {0}!",
+            "arrayInvalidTypes": "Этот массив может содержать только следующие типы: {0}!",
+            "arrayDouble": "Этот массив не допускает повторяющихся значений!",
+            "discordInvalidId": "Это недействительный идентификатор {0} в Discord!",
+            "discordInvalidIdOptions": "Это недействительный идентификатор {0} в Discord! Вы также можете использовать один из следующих: {1}!",
+            "discordInvalidToken": "Это недействительный токен Discord (синтаксически)!",
+            "colorInvalid": "Это недействительный шестнадцатеричный цвет!",
+            "emojiTooShort": "Эта строка должна содержать не менее {0} эмодзи!",
+            "emojiTooLong": "Эта строка должна содержать не более {0} эмодзи!",
+            "emojiCustom": "Этот эмодзи не может быть пользовательским эмодзи Discord!",
+            "emojiInvalid": "Это недействительный эмодзи!",
+            "urlInvalid": "Этот URL недействителен!",
+            "urlInvalidHttp": "Этот URL может использовать только протокол https://!",
+            "urlInvalidProtocol": "Этот URL может использовать только протоколы http:// и https://!",
+            "urlInvalidHostname": "Этот URL имеет недопустимое имя хоста!",
+            "urlInvalidExtension": "Этот URL имеет недействительное расширение! Выберите из: {0}!",
+            "urlInvalidPath": "Этот URL имеет недействительный путь!",
+            "idNotUnique": "Этот идентификатор не уникален, используйте другой идентификатор!",
+            "idNonExistent": "Идентификатор {0} не существует!",
+            "invalidType": "Это свойство должно быть типа: {0}!",
+            "propertyMissing": "Свойство {0} отсутствует в этом объекте!",
+            "propertyOptional": "Свойство {0} необязательно в этом объекте!",
+            "objectDisabled": "Этот объект отключен, включите его с помощью {0}!",
+            "nullInvalid": "Это свойство не может быть null!",
+            "switchInvalidType": "Это должно быть одним из следующих типов: {0}!",
+            "objectSwitchInvalid": "Этот объект должен быть одним из следующих типов: {0}!",
+            "invalidLanguage": "Это недействительный язык!",
+            "invalidButton": "Эта кнопка должна иметь хотя бы {0} или {1}!",
+            "unusedOption": "Опция {0} нигде не используется!",
+            "unusedQuestion": "Вопрос {0} нигде не используется!",
+            "dropdownOption": "Панель с включенным выпадающим списком может содержать только опции типа 'ticket'!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Посетить тикет",
+            "close": "Закрыть тикет",
+            "delete": "Удалить тикет",
+            "reopen": "Переоткрыть тикет",
+            "claim": "Забрать тикет",
+            "unclaim": "Отказаться от тикета",
+            "pin": "Закрепить тикет",
+            "unpin": "Открепить тикет",
+            "clear": "Удалить тикеты",
+            "helpSwitchSlash": "Просмотреть слэш-команды",
+            "helpSwitchText": "Просмотреть текстовые команды",
+            "helpPage": "Страница {0}",
+            "withReason": "С причиной",
+            "withoutTranscript": "Без стенограммы"
+        },
+        "titles": {
+            "created": "Тикет создан",
+            "close": "Тикет закрыт",
+            "delete": "Тикет удален",
+            "reopen": "Тикет переоткрыт",
+            "claim": "Тикет забран",
+            "unclaim": "Тикет освобожден",
+            "pin": "Тикет закреплен",
+            "unpin": "Тикет откреплен",
+            "rename": "Тикет переименован",
+            "move": "Тикет перемещен",
+            "add": "Пользователь добавлен в тикет",
+            "remove": "Пользователь удален из тикета",
+            "help": "Доступные команды",
+            "statsReset": "Сбросить статистику",
+            "blacklistAdd": "Пользователь в черном списке",
+            "blacklistRemove": "Пользователь освобожден",
+            "blacklistGet": "Пользователь в черном списке",
+            "blacklistView": "Текущий черный список",
+            "blacklistAddDm": "Добавлен в черный список",
+            "blacklistRemoveDm": "Удален из черного списка",
+            "clear": "Тикеты очищены",
+            "roles": "Роли обновлены",
+            "autoclose": "Тикет автоматически закрыт",
+            "autocloseEnabled": "Автозакрытие включено",
+            "autocloseDisabled": "Автозакрытие отключено",
+            "autodelete": "Тикет автоматически удален",
+            "autodeleteEnabled": "Автоудаление включено",
+            "autodeleteDisabled": "Автоудаление отключено"
+        },
+        "descriptions": {
+            "create": "Ваш тикет был создан. Нажмите кнопку ниже, чтобы получить к нему доступ!",
+            "close": "Тикет был успешно закрыт!",
+            "delete": "Тикет был успешно удален!",
+            "reopen": "Тикет был успешно переоткрыт!",
+            "claim": "Тикет был успешно забран!",
+            "unclaim": "Тикет был успешно освобожден!",
+            "pin": "Тикет был успешно закреплен!",
+            "unpin": "Тикет был успешно откреплен!",
+            "rename": "Тикет был успешно переименован в {0}!",
+            "move": "Тикет был успешно перемещен в {0}!",
+            "add": "{0} был успешно добавлен в тикет!",
+            "remove": "{0} был успешно удален из тикета!",
+            "helpExplanation": "`<name>` => обязательный параметр\n`[name]` => необязательный параметр",
+            "statsReset": "Статистика бота была успешно сброшена!",
+            "statsError": "Невозможно просмотреть статистику тикета!\n{0} не является тикетом!",
+            "blacklistAdd": "{0} был успешно добавлен в черный список!",
+            "blacklistRemove": "{0} был успешно удален из черного списка!",
+            "blacklistGetSuccess": "{0} в настоящее время в черном списке!",
+            "blacklistGetEmpty": "{0} в настоящее время не в черном списке!",
+            "blacklistViewEmpty": "Никто еще не был добавлен в черный список!",
+            "blacklistViewTip": "Используйте \"/blacklist add\", чтобы добавить пользователя в черный список!",
+            "clearVerify": "Вы уверены, что хотите удалить несколько тикетов?\nЭто действие не может быть отменено!",
+            "clearReady": "{0} тикетов были успешно удалены!",
+            "rolesEmpty": "Ни одна роль не была обновлена!",
+            "autocloseLeave": "Этот тикет был автоматически закрыт, потому что создатель покинул сервер!",
+            "autocloseTimeout": "Этот тикет был автоматически закрыт, потому что он был неактивен более `{0}ч`!",
+            "autodeleteLeave": "Этот тикет был автоматически удален, потому что создатель покинул сервер!",
+            "autodeleteTimeout": "Этот тикет был автоматически удален, потому что он был неактивен более `{0} дней`!",
+            "autocloseEnabled": "Автозакрытие было включено для этого тикета!\nОн будет закрыт, если будет неактивен более `{0}ч`!",
+            "autocloseDisabled": "Автозакрытие было отключено для этого тикета!\nОн больше не будет закрываться автоматически!",
+            "autodeleteEnabled": "Автоудаление было включено для этого тикета!\nОн будет удален, если будет неактивен более `{0} дней`!",
+            "autodeleteDisabled": "Автоудаление было отключено для этого тикета!\nОн больше не будет удаляться автоматически!",
+            "ticketMessageLimit": "Вы можете создать только {0} тикет(ов) одновременно!",
+            "ticketMessageAutoclose": "Этот тикет будет автоматически закрыт, если будет неактивен {0}ч!",
+            "ticketMessageAutodelete": "Этот тикет будет автоматически удален, если будет неактивен {0} дней!",
+            "panelReady": "Вы можете найти панель ниже!\nЭто сообщение теперь можно удалить!"
+        },
+        "modal": {
+            "closePlaceholder": "Почему вы закрыли этот тикет?",
+            "deletePlaceholder": "Почему вы удалили этот тикет?",
+            "reopenPlaceholder": "Почему вы переоткрыли этот тикет?",
+            "claimPlaceholder": "Почему вы забрали этот тикет?",
+            "unclaimPlaceholder": "Почему вы отказались от этого тикета?",
+            "pinPlaceholder": "Почему вы закрепили этот тикет?",
+            "unpinPlaceholder": "Почему вы открепили этот тикет?"
+        },
+        "logs": {
+            "createLog": "Новый тикет был создан {0}!",
+            "closeLog": "Этот тикет был закрыт {0}!",
+            "closeDm": "Ваш тикет был закрыт на нашем сервере!",
+            "deleteLog": "Этот тикет был удален {0}!",
+            "deleteDm": "Ваш тикет был удален на нашем сервере!",
+            "reopenLog": "Этот тикет был переоткрыт {0}!",
+            "reopenDm": "Ваш тикет был переоткрыт на нашем сервере!",
+            "claimLog": "Этот тикет был забран {0}!",
+            "claimDm": "Ваш тикет был забран на нашем сервере!",
+            "unclaimLog": "Этот тикет был освобожден {0}!",
+            "unclaimDm": "Ваш тикет был освобожден на нашем сервере!",
+            "pinLog": "Этот тикет был закреплен {0}!",
+            "pinDm": "Ваш тикет был закреплен на нашем сервере!",
+            "unpinLog": "Этот тикет был откреплен {0}!",
+            "unpinDm": "Ваш тикет был откреплен на нашем сервере!",
+            "renameLog": "Этот тикет был переименован в {0} пользователем {1}!",
+            "renameDm": "Ваш тикет был переименован в {0} на нашем сервере!",
+            "moveLog": "Этот тикет был перемещен в {0} пользователем {1}!",
+            "moveDm": "Ваш тикет был перемещен в {0} на нашем сервере!",
+            "addLog": "{0} был добавлен в этот тикет пользователем {1}!",
+            "addDm": "{0} был добавлен в ваш тикет на нашем сервере!",
+            "removeLog": "{0} был удален из этого тикета пользователем {1}!",
+            "removeDm": "{0} был удален из вашего тикета на нашем сервере!",
+            "blacklistAddLog": "{0} был добавлен в черный список {1}!",
+            "blacklistRemoveLog": "{0} был удален из черного списка {1}!",
+            "blacklistAddDm": "Вы были добавлены в черный список на нашем сервере!\nОтныне вы не можете создавать тикеты!",
+            "blacklistRemoveDm": "Вы были удалены из черного списка на нашем сервере!\nТеперь вы снова можете создавать тикеты!",
+            "clearLog": "{0} тикетов были удалены {1}!"
+        }
+    },
+    "transcripts": {
+        "success": {
+            "visit": "Посетить стенограмму",
+            "ready": "Стенограмма создана",
+            "textFileDescription": "Это текстовая стенограмма удаленного тикета!",
+            "htmlProgress": "Пожалуйста, подождите, пока эта html-стенограмма обрабатывается...",
+            "createdChannel": "Новая {0} стенограмма была создана на сервере!",
+            "createdCreator": "Новая {0} стенограмма была создана для одного из ваших тикетов!",
+            "createdParticipant": "Новая {0} стенограмма была создана в одном из тикетов, в котором вы участвовали!",
+            "createdActiveAdmin": "Новая {0} стенограмма была создана в одном из тикетов, в котором вы участвовали как администратор!",
+            "createdEveryAdmin": "Новая {0} стенограмма была создана в одном из тикетов, в котором вы были администратором!",
+            "createdOther": "Новая {0} стенограмма была создана!"
+        },
+        "errors": {
+            "retry": "Повторить",
+            "continue": "Удалить без стенограммы",
+            "backup": "Создать резервную стенограмму",
+            "error": "Что-то пошло не так при попытке создать стенограмму.\nЧто вы хотите сделать?\n\nЭтот тикет не будет удален, пока вы не нажмете одну из этих кнопок."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Внутренняя ошибка",
+            "optionMissing": "Отсутствует опция команды",
+            "optionInvalid": "Недействительная опция команды",
+            "unknownCommand": "Неизвестная команда",
+            "noPermissions": "Нет разрешений",
+            "unknownTicket": "Неизвестный тикет",
+            "deprecatedTicket": "Устаревший тикет",
+            "unknownOption": "Неизвестная опция",
+            "unknownPanel": "Неизвестная панель",
+            "notInGuild": "Не на сервере",
+            "channelRename": "Невозможно переименовать канал",
+            "busy": "Тикет занят"
+        },
+        "descriptions": {
+            "askForInfo": "Свяжитесь с владельцем этого бота для получения дополнительной информации!",
+            "askForInfoResolve": "Свяжитесь с владельцем бота, если эта проблема не решится после нескольких попыток.",
+            "internalError": "Не удалось ответить на это {0} из-за внутренней ошибки!",
+            "optionMissing": "В этой команде отсутствует обязательный параметр!",
+            "optionInvalid": "Параметр в этой команде недействителен!",
+            "optionInvalidChoose": "Выберите из",
+            "unknownCommand": "Попробуйте посетить меню помощи для получения дополнительной информации!",
+            "noPermissions": "Вам не разрешено использовать это {0}!",
+            "noPermissionsList": "Требуемые разрешения: (одно из них)",
+            "noPermissionsCooldown": "Вам не разрешено использовать это {0}, потому что у вас есть перезарядка!",
+            "noPermissionsBlacklist": "Вам не разрешено использовать это {0}, потому что вы были добавлены в черный список!",
+            "noPermissionsLimitGlobal": "Вам не разрешено создавать тикет, потому что сервер достиг максимального предела тикетов!",
+            "noPermissionsLimitGlobalUser": "Вам не разрешено создавать тикет, потому что вы достигли максимального предела тикетов!",
+            "noPermissionsLimitOption": "Вам не разрешено создавать тикет, потому что сервер достиг максимального предела тикетов для этой опции!",
+            "noPermissionsLimitOptionUser": "Вам не разрешено создавать тикет, потому что вы достигли максимального предела тикетов для этой опции!",
+            "unknownTicket": "Попробуйте эту команду еще раз в действительном тикете!",
+            "deprecatedTicket": "Текущий канал не является действительным тикетом! Возможно, это был тикет из старой версии Open Ticket!",
+            "notInGuild": "Это {0} не работает в ЛС! Пожалуйста, попробуйте еще раз на сервере!",
+            "channelRename": "Из-за ограничений Discord на частоту запросов, боту сейчас невозможно переименовать канал. Канал будет автоматически переименован через 10 минут, если бот не будет перезагружен.",
+            "channelRenameSource": "Источник этой ошибки: {0}",
+            "busy": "Невозможно использовать это {0}!\nТикет в настоящее время обрабатывается ботом.\n\nПожалуйста, попробуйте еще раз через несколько секунд!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Значение не соответствует шаблону!",
+            "stringMinLength": "Значение должно быть не менее {0} символов!",
+            "stringMaxLength": "Значение должно быть не более {0} символов!",
+            "numberInvalid": "Недействительное число!",
+            "numberMin": "Число должно быть не менее {0}!",
+            "numberMax": "Число должно быть не более {0}!",
+            "numberDecimal": "Число не может быть десятичным!",
+            "numberNegative": "Число не может быть отрицательным!",
+            "numberPositive": "Число не может быть положительным!",
+            "numberZero": "Число не может быть нулем!",
+            "channelNotFound": "Невозможно найти канал!",
+            "userNotFound": "Невозможно найти пользователя!",
+            "roleNotFound": "Невозможно найти роль!",
+            "memberNotFound": "Невозможно найти пользователя!",
+            "mentionableNotFound": "Невозможно найти пользователя или роль!",
+            "channelType": "Недействительный тип канала!",
+            "notInGuild": "Для этой опции вам нужно быть на сервере!"
+        },
+        "permissions": {
+            "developer": "Вы должны быть разработчиком бота.",
+            "owner": "Вы должны быть владельцем сервера.",
+            "admin": "Вы должны быть администратором сервера.",
+            "moderator": "Вы должны быть модератором.",
+            "support": "Вы должны быть в команде поддержки.",
+            "member": "Вы должны быть участником.",
+            "discord-administrator": "У вас должно быть разрешение `ADMINISTRATOR`."
+        },
+        "actionInvalid": {
+            "close": "Тикет уже закрыт!",
+            "reopen": "Тикет еще не закрыт!",
+            "claim": "Тикет уже забран!",
+            "unclaim": "Тикет еще не забран!",
+            "pin": "Тикет уже закреплен!",
+            "unpin": "Тикет еще не закреплен!",
+            "add": "Этот пользователь уже имеет доступ к тикету!",
+            "remove": "Невозможно удалить этого пользователя из тикета!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Тикет",
+            "tickets": "Тикеты",
+            "reason": "Причина",
+            "creator": "Создатель",
+            "remaining": "Оставшееся время",
+            "added": "Добавлен",
+            "removed": "Удален",
+            "filter": "Фильтр",
+            "claimedBy": "Забран {0}",
+            "method": "Метод",
+            "type": "Тип",
+            "blacklisted": "В черном списке",
+            "panel": "Панель",
+            "command": "Команда",
+            "system": "Система",
+            "true": "Истина",
+            "false": "Ложь",
+            "syntax": "Синтаксис",
+            "originalName": "Исходное имя",
+            "newName": "Новое имя",
+            "until": "До",
+            "validOptions": "Действительные опции",
+            "validPanels": "Действительные панели",
+            "autoclose": "Автозакрытие",
+            "autodelete": "Автоудаление",
+            "startupDate": "Дата запуска",
+            "version": "Версия",
+            "name": "Имя",
+            "role": "Роль",
+            "status": "Статус",
+            "claimed": "Забран",
+            "pinned": "Закреплен",
+            "creationDate": "Дата создания"
+        },
+        "lowercase": {
+            "text": "текст",
+            "html": "html",
+            "command": "команда",
+            "modal": "модальное окно",
+            "button": "кнопка",
+            "dropdown": "выпадающий список",
+            "method": "метод"
+        }
+    },
+    "commands": {
+        "reason": "Укажите необязательную причину, которая будет видна в журналах.",
+        "help": "Получите список всех доступных команд.",
+        "panel": "Создайте сообщение с выпадающим списком или кнопками (для создания тикета).",
+        "panelId": "Идентификатор панели, которую вы хотите создать.",
+        "panelAutoUpdate": "Хотите ли вы, чтобы эта панель автоматически обновлялась при редактировании?",
+        "ticket": "Мгновенно создать тикет.",
+        "ticketId": "Идентификатор тикета, который вы хотите создать.",
+        "close": "Закрыть тикет.",
+        "delete": "Удалить тикет.",
+        "deleteNoTranscript": "Удалить этот тикет без создания стенограммы.",
+        "reopen": "Переоткрыть тикет.",
+        "claim": "Забрать тикет.",
+        "claimUser": "Забрать этот тикет для кого-то другого, а не для себя.",
+        "unclaim": "Отказаться от тикета.",
+        "pin": "Закрепить тикет.",
+        "unpin": "Открепить тикет.",
+        "move": "Переместить тикет.",
+        "moveId": "Идентификатор опции, в которую вы хотите переместить.",
+        "rename": "Переименовать тикет.",
+        "renameName": "Новое имя для этого тикета.",
+        "add": "Добавить пользователя в тикет.",
+        "addUser": "Пользователь, которого нужно добавить.",
+        "remove": "Удалить пользователя из тикета.",
+        "removeUser": "Пользователь, которого нужно удалить.",
+        "blacklist": "Управление черным списком тикетов.",
+        "blacklistView": "Просмотреть список текущего черного списка.",
+        "blacklistAdd": "Добавить пользователя в черный список.",
+        "blacklistRemove": "Удалить пользователя из черного списка.",
+        "blacklistGet": "Получить подробности о пользователе в черном списке.",
+        "blacklistGetUser": "Пользователь, о котором нужно получить подробности.",
+        "stats": "Просмотреть статистику бота, участника или тикета.",
+        "statsReset": "Сбросить всю статистику бота (и начать отсчет с нуля).",
+        "statsGlobal": "Просмотреть глобальную статистику.",
+        "statsUser": "Просмотреть статистику пользователя на сервере.",
+        "statsUserUser": "Пользователь для просмотра.",
+        "statsTicket": "Просмотреть статистику тикета на сервере.",
+        "statsTicketTicket": "Тикет для просмотра.",
+        "clear": "Удалить несколько тикетов одновременно.",
+        "clearFilter": "Фильтр для очистки тикетов.",
+        "clearFilters": {
+            "all": "Все",
+            "open": "Открытые",
+            "close": "Закрытые",
+            "claim": "Забранные",
+            "unclaim": "Не забранные",
+            "pin": "Закрепленные",
+            "unpin": "Не закрепленные",
+            "autoclose": "Автоматически закрытые"
+        },
+        "autoclose": "Управление автозакрытием в тикете.",
+        "autocloseDisable": "Отключить автозакрытие в этом тикете.",
+        "autocloseEnable": "Включить автозакрытие в этом тикете.",
+        "autocloseEnableTime": "Количество часов, в течение которых тикет должен быть неактивен, чтобы закрыть его.",
+        "autodelete": "Управление автоудалением в тикете.",
+        "autodeleteDisable": "Отключить автоудаление в этом тикете.",
+        "autodeleteEnable": "Включить автоудаление в этом тикете.",
+        "autodeleteEnableTime": "Количество дней, в течение которых тикет должен быть неактивен, чтобы удалить его."
+    },
+    "helpMenu": {
+        "help": "Получите список всех доступных команд.",
+        "ticket": "Мгновенно создать тикет.",
+        "close": "Закрыть тикет, это отключает запись в этом канале.",
+        "delete": "Удалить тикет, это создает стенограмму, если включено.",
+        "reopen": "Переоткрыть тикет, это снова включает запись в этом канале.",
+        "pin": "Закрепить тикет. Это переместит тикет наверх и добавит к имени эмодзи '📌'.",
+        "unpin": "Открепить тикет. Тикет останется на своем месте, но потеряет эмодзи '📌'.",
+        "move": "Переместить тикет. Это изменит тип этого тикета.",
+        "rename": "Переименовать тикет. Это изменит имя канала этого тикета.",
+        "claim": "Забрать тикет. С помощью этого вы можете сообщить своей команде, что вы обрабатываете этот тикет.",
+        "unclaim": "Отказаться от тикета. С помощью этого вы можете сообщить своей команде, что этот тикет снова свободен.",
+        "add": "Добавить пользователя в тикет. Это позволит пользователю читать и писать в этом тикете.",
+        "remove": "Удалить пользователя из тикета. Это удалит возможность читать и писать для пользователя в этом тикете.",
+        "panel": "Создайте сообщение с выпадающим списком или кнопками (для создания тикета).",
+        "blacklistView": "Просмотреть список текущего черного списка.",
+        "blacklistAdd": "Добавить пользователя в черный список.",
+        "blacklistRemove": "Удалить пользователя из черного списка.",
+        "blacklistGet": "Получить подробности о пользователе в черном списке.",
+        "statsGlobal": "Просмотреть глобальную статистику.",
+        "statsTicket": "Просмотреть статистику тикета на сервере.",
+        "statsUser": "Просмотреть статистику пользователя на сервере.",
+        "statsReset": "Сбросить всю статистику бота (и начать отсчет с нуля).",
+        "autocloseDisable": "Отключить автозакрытие в этом тикете.",
+        "autocloseEnable": "Включить автозакрытие в этом тикете.",
+        "autodeleteDisable": "Отключить автоудаление в этом тикете.",
+        "autodeleteEnable": "Включить автоудаление в этом тикете."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Глобальная статистика",
+            "system": "Статистика системы",
+            "user": "Статистика пользователя",
+            "ticket": "Статистика тикета",
+            "participants": "Участники"
+        },
+        "properties": {
+            "ticketsCreated": "Тикеты созданы",
+            "ticketsClosed": "Тикеты закрыты",
+            "ticketsDeleted": "Тикеты удалены",
+            "ticketsReopened": "Тикеты переоткрыты",
+            "ticketsAutoclosed": "Тикеты автоматически закрыты",
+            "ticketsClaimed": "Тикеты забраны",
+            "ticketsPinned": "Тикеты закреплены",
+            "ticketsMoved": "Тикеты перемещены",
+            "usersBlacklisted": "Пользователи в черном списке",
+            "transcriptsCreated": "Стенограммы созданы"
+        }
+    }
+}
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["Redactado","Josuens"],
        "lastedited":"22/08/2024",
        "language":"Spanish",
@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.4",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Svenska",
+        "automated": false
+    },
+    "checker": {
+        "system": {
+            "typeError": "[FEL]",
+            "headerOpenTicket":"OPEN TICKET",
+            "typeWarning": "[VARNING]",
+            "typeInfo": "[INFO]",
+            "headerConfigChecker": "KONFIGURATIONSKONTROLL",
+            "headerDescription": "kontrollera efter fel i din konfiguration!",
+            "footerError": "botten startar inte förrän alla {0} är fixade!",
+            "footerWarning": "det rekommenderas att fixa alla {0} före start!",
+            "footerSupport": "SUPPORT: {0} - DOKUMENTATION: {1}",
+            "compactInformation": "använd {0} för mer information!",
+            "dataPath": "sökväg",
+            "dataDocs": "dokumentation",
+            "dataMessages": "meddelande"
+        },
+        "messages": {
+            "stringTooShort": "Denna sträng kan inte vara kortare än {0} tecken!",
+            "stringTooLong": "Denna sträng kan inte vara längre än {0} tecken!",
+            "stringLengthInvalid": "Denna sträng ska vara {0} tecken lång!",
+            "stringStartsWith": "Denna sträng ska börja med {0}!",
+            "stringEndsWith": "Denna sträng ska sluta med {0}!",
+            "stringContains": "Denna sträng ska innehålla {0}!",
+            "stringChoices": "Denna sträng kan endast vara en av följande värden: {0}!",
+            "stringRegex": "Denna sträng är ogiltig!",
+
+            "numberTooShort": "Detta tal kan inte vara kortare än {0} tecken!",
+            "numberTooLong": "Detta tal kan inte vara längre än {0} tecken!",
+            "numberLengthInvalid": "Detta tal ska vara {0} tecken långt!",
+            "numberTooSmall": "Detta tal ska vara minst {0}!",
+            "numberTooLarge": "Detta tal ska vara högst {0}!",
+            "numberNotEqual": "Detta tal ska vara {0}!",
+            "numberStep": "Detta tal ska vara en multipel av {0}!",
+            "numberStepOffset": "Detta tal ska vara en multipel av {0}, med start från {1}!",
+            "numberStartsWith": "Detta tal ska börja med {0}!",
+            "numberEndsWith": "Detta tal ska sluta med {0}!",
+            "numberContains": "Detta tal ska innehålla {0}!",
+            "numberChoices": "Detta tal kan endast vara en av följande värden: {0}!",
+            "numberFloat": "Detta tal kan inte vara ett decimaltal!",
+            "numberNegative": "Detta tal kan inte vara negativt!",
+            "numberPositive": "Detta tal kan inte vara positivt!",
+            "numberZero": "Detta tal kan inte vara noll!",
+
+            "booleanTrue": "Detta booleska värde kan inte vara sant!",
+            "booleanFalse": "Detta booleska värde kan inte vara falskt!",
+
+            "arrayEmptyDisabled": "Denna lista kan inte vara tom!",
+            "arrayEmptyRequired": "Denna lista ska vara tom!",
+            "arrayTooShort": "Denna lista ska ha en längd på minst {0}!",
+            "arrayTooLong": "Denna lista ska ha en längd på högst {0}!",
+            "arrayLengthInvalid": "Denna lista ska ha en längd på {0}!",
+            "arrayInvalidTypes": "Denna lista kan endast innehålla följande typer: {0}!",
+            "arrayDouble": "Denna lista tillåter inte samma värde två gånger!",
+
+            "discordInvalidId": "Detta är en ogiltig Discord {0} ID!",
+            "discordInvalidIdOptions": "Detta är en ogiltig Discord {0} ID! Du kan också använda en av dessa: {1}!",
+            "discordInvalidToken": "Detta är en ogiltig Discord-token (syntaktiskt)!",
+            "colorInvalid": "Detta är en ogiltig hexadecimal färg!",
+            "emojiTooShort": "Denna sträng ska ha minst {0} emojis!",
+            "emojiTooLong": "Denna sträng ska ha högst {0} emojis!",
+            "emojiCustom": "Denna emoji kan inte vara en anpassad Discord-emoji!",
+            "emojiInvalid": "Detta är en ogiltig emoji!",
+            "urlInvalid": "Denna URL är ogiltig!",
+            "urlInvalidHttp": "Denna URL kan endast använda https://-protokollet!",
+            "urlInvalidProtocol": "Denna URL kan endast använda http://- och https://-protokollen!",
+            "urlInvalidHostname": "Denna URL har ett otillåtet värdnamn!",
+            "urlInvalidExtension": "Denna URL har en ogiltig filtyp! Välj mellan: {0}!",
+            "urlInvalidPath": "Denna URL har en ogiltig sökväg!",
+            "idNotUnique": "Detta ID är inte unikt, använd ett annat ID istället!",
+            "idNonExistent": "ID {0} existerar inte!",
+
+            "invalidType": "Denna egenskap ska vara av typen: {0}!",
+            "propertyMissing": "Egenskapen {0} saknas i detta objekt!",
+            "propertyOptional": "Egenskapen {0} är valfri i detta objekt!",
+            "objectDisabled": "Detta objekt är inaktiverat, aktivera det genom att använda {0}!",
+            "nullInvalid": "Denna egenskap kan inte vara null!",
+            "switchInvalidType": "Detta ska vara en av följande typer: {0}!",
+            "objectSwitchInvalid": "Detta objekt ska vara en av följande typer: {0}!",
+
+            "invalidLanguage": "Detta är ett ogiltigt språk!",
+            "invalidButton": "Denna knapp ska ha minst en {0} eller {1}!",
+            "unusedOption": "Alternativet {0} används inte någonstans!",
+            "unusedQuestion": "Frågan {0} används inte någonstans!",
+            "dropdownOption": "Ett panel med dropdown aktiverad kan endast innehålla alternativ av typen 'ärende'!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Skapa Ärende",
+            "close": "Stäng Ärende",
+            "delete": "Radera Ärende",
+            "reopen": "Återöppna Ärende",
+            "claim": "Ta Ärende",
+            "unclaim": "Frigör Ärende",
+            "pin": "Fäst Ärende",
+            "unpin": "Lossa Ärende",
+            "clear": "Radera Ärenden",
+            "helpSwitchSlash": "Visa Slash-kommandon",
+            "helpSwitchText": "Visa Textkommandon",
+            "helpPage": "Sida {0}",
+            "withReason": "Med Orsak",
+            "withoutTranscript": "Utan Utskrift"
+        },
+        "titles": {
+            "created": "Ärende Skapat",
+            "close": "Ärende Stängt",
+            "delete": "Ärende Raderat",
+            "reopen": "Ärende Återöppnat",
+            "claim": "Ärende Taget",
+            "unclaim": "Ärende Frigjort",
+            "pin": "Ärende Fäst",
+            "unpin": "Ärende Lossat",
+            "rename": "Ärende Omdöpt",
+            "move": "Ärende Flyttat",
+            "add": "Användare Tillagd i Ärende",
+            "remove": "Användare Borttagen Från Ärende",
+
+            "help": "Tillgängliga Kommandon",
+            "statsReset": "Återställ Statistik",
+            "blacklistAdd": "Användare Svartlistad",
+            "blacklistRemove": "Användare Borttagen Från Svartlista",
+            "blacklistGet": "Svartlistad Användare",
+            "blacklistView": "Nuvarande Svartlista",
+            "blacklistAddDm": "Tillagd i Svartlista",
+            "blacklistRemoveDm": "Borttagen Från Svartlista",
+            "clear": "Ärenden Raderade",
+            "roles": "Roller Uppdaterade",
+
+            "autoclose": "Ärende Autostängt",
+            "autocloseEnabled": "Autostängning Aktiverad",
+            "autocloseDisabled": "Autostängning Inaktiverad",
+            "autodelete": "Ärende Autoraderat",
+            "autodeleteEnabled": "Autoradering Aktiverad",
+            "autodeleteDisabled": "Autoradering Inaktiverad"
+        },
+        "descriptions": {
+            "create": "Ditt ärende har skapats. Klicka på knappen nedan för att få tillgång till det!",
+            "close": "Ärendet har stängts framgångsrikt!",
+            "delete": "Ärendet har raderats framgångsrikt!",
+            "reopen": "Ärendet har återöppnats framgångsrikt!",
+            "claim": "Ärendet har tagits framgångsrikt!",
+            "unclaim": "Ärendet har frigjorts framgångsrikt!",
+            "pin": "Ärendet har fästs framgångsrikt!",
+            "unpin": "Ärendet har lossats framgångsrikt!",
+            "rename": "Ärendet har döpts om till {0} framgångsrikt!",
+            "move": "Ärendet har flyttats till {0} framgångsrikt!",
+            "add": "{0} har lagts till i ärendet framgångsrikt!",
+            "remove": "{0} har tagits bort från ärendet framgångsrikt!",
+
+            "helpExplanation": "`<namn>` => obligatorisk parameter\n`[namn]` => valfri parameter",
+            "statsReset": "Bottens statistik har återställts framgångsrikt!",
+            "statsError": "Kan inte visa ärendestatistik!\n{0} är inte ett ärende!",
+            "blacklistAdd": "{0} har svartlistats framgångsrikt!",
+            "blacklistRemove": "{0} har tagits bort från svartlistan framgångsrikt!",
+            "blacklistGetSuccess": "{0} är för närvarande svartlistad!",
+            "blacklistGetEmpty": "{0} är för närvarande inte svartlistad!",
+            "blacklistViewEmpty": "Ingen är svartlistad ännu!",
+            "blacklistViewTip": "Använd \"/blacklist add\" för att svartlista en användare!",
+            "clearVerify": "Är du säker på att du vill radera flera ärenden?\nDenna åtgärd kan inte ångras!",
+            "clearReady": "{0} ärenden har raderats framgångsrikt!",
+            "rolesEmpty": "Inga roller har uppdaterats!",
+
+            "autocloseLeave": "Detta ärende har autostängts eftersom skaparen lämnade servern!",
+            "autocloseTimeout": "Detta ärende har autostängts eftersom det har varit inaktivt i mer än `{0}t`!",
+            "autodeleteLeave": "Detta ärende har autoraderats eftersom skaparen lämnade servern!",
+            "autodeleteTimeout": "Detta ärende har autoraderats eftersom det har varit inaktivt i mer än `{0} dagar`!",
+            "autocloseEnabled": "Autostängning har aktiverats i detta ärende!\nDet kommer att stängas när det är inaktivt i mer än `{0}t`!",
+            "autocloseDisabled": "Autostängning har inaktiverats i detta ärende!\nDet kommer inte längre att stängas automatiskt!",
+            "autodeleteEnabled": "Autoradering har aktiverats i detta ärende!\nDet kommer att raderas när det är inaktivt i mer än `{0} dagar`!",
+            "autodeleteDisabled": "Autoradering har inaktiverats i detta ärende!\nDet kommer inte längre att raderas automatiskt!",
+
+            "ticketMessageLimit": "Du kan endast skapa {0} ärende(n) åt gången!",
+            "ticketMessageAutoclose": "Detta ärende kommer att autostängas när det är inaktivt i {0}t!",
+            "ticketMessageAutodelete": "Detta ärende kommer att autoraderas när det är inaktivt i {0} dagar!",
+            "panelReady": "Du hittar panelen nedan!\nDetta meddelande kan nu raderas!"
+        },
+        "modal": {
+            "closePlaceholder": "Varför stängde du detta ärende?",
+            "deletePlaceholder": "Varför raderade du detta ärende?",
+            "reopenPlaceholder": "Varför återöppnade du detta ärende?",
+            "claimPlaceholder": "Varför tog du detta ärende?",
+            "unclaimPlaceholder": "Varför frigjorde du detta ärende?",
+            "pinPlaceholder": "Varför fäste du detta ärende?",
+            "unpinPlaceholder": "Varför lossade du detta ärende?"
+        },
+        "logs": {
+            "createLog": "Ett nytt ärende har skapats av {0}!",
+            "closeLog": "Detta ärende har stängts av {0}!",
+            "closeDm": "Ditt ärende har stängts på vår server!",
+            "deleteLog": "Detta ärende har raderats av {0}!",
+            "deleteDm": "Ditt ärende har raderats på vår server!",
+            "reopenLog": "Detta ärende har återöppnats av {0}!",
+            "reopenDm": "Ditt ärende har återöppnats på vår server!",
+            "claimLog": "Detta ärende har tagits av {0}!",
+            "claimDm": "Ditt ärende har tagits på vår server!",
+            "unclaimLog": "Detta ärende har frigjorts av {0}!",
+            "unclaimDm": "Ditt ärende har frigjorts på vår server!",
+            "pinLog": "Detta ärende har fästs av {0}!",
+            "pinDm": "Ditt ärende har fästs på vår server!",
+            "unpinLog": "Detta ärende har lossats av {0}!",
+            "unpinDm": "Ditt ärende har lossats på vår server!",
+            "renameLog": "Detta ärende har döpts om till {0} av {1}!",
+            "renameDm": "Ditt ärende har döpts om till {0} på vår server!",
+            "moveLog": "Detta ärende har flyttats till {0} av {1}!",
+            "moveDm": "Ditt ärende har flyttats till {0} på vår server!",
+            "addLog": "{0} har lagts till i detta ärende av {1}!",
+            "addDm": "{0} har lagts till i ditt ärende på vår server!",
+            "removeLog": "{0} har tagits bort från detta ärende av {1}!",
+            "removeDm": "{0} har tagits bort från ditt ärende på vår server!",
+
+            "blacklistAddLog": "{0} har svartlistats av {1}!",
+            "blacklistRemoveLog": "{0} har tagits bort från svartlistan av {1}!",
+            "blacklistAddDm": "Du har svartlistats på vår server!\nFrån och med nu kan du inte skapa ett ärende!",
+            "blacklistRemoveDm": "Du har tagits bort från svartlistan på vår server!\nNu kan du skapa ärenden igen!",
+            "clearLog": "{0} ärenden har raderats av {1}!"
+        }
+    },
+    "transcripts": {
+        "success": {
+            "visit": "Besök Utskrift",
+            "ready": "Utskrift Skapad",
+            "textFileDescription": "Detta är textutskriften av ett raderat ärende!",
+            "htmlProgress": "Vänligen vänta medan denna HTML-utskrift bearbetas...",
+
+            "createdChannel": "En ny {0} utskrift har skapats på servern!",
+            "createdCreator": "En ny {0} utskrift har skapats för ett av dina ärenden!",
+            "createdParticipant": "En ny {0} utskrift har skapats i ett av ärendena du deltog i!",
+            "createdActiveAdmin": "En ny {0} utskrift har skapats i ett av ärendena du deltog i som admin!",
+            "createdEveryAdmin": "En ny {0} utskrift har skapats i ett av ärendena du var admin i!",
+            "createdOther": "En ny {0} utskrift har skapats!"
+        },
+        "errors": {
+            "retry": "Försök Igen",
+            "continue": "Radera Utan Utskrift",
+            "backup": "Skapa Säkerhetskopieringsutskrift",
+            "error": "Något gick fel vid försöket att skapa utskriften.\nVad vill du göra?\n\nDetta ärende kommer inte att raderas förrän du klickar på en av dessa knappar."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Internt Fel",
+            "optionMissing": "Kommandoalternativ Saknas",
+            "optionInvalid": "Ogiltigt Kommandoalternativ",
+            "unknownCommand": "Okänt Kommando",
+            "noPermissions": "Inga Behörigheter",
+            "unknownTicket": "Okänt Ärende",
+            "deprecatedTicket": "Utgånget Ärende",
+            "unknownOption": "Okänt Alternativ",
+            "unknownPanel": "Okänt Panel",
+            "notInGuild": "Inte På Server",
+            "channelRename": "Kan Inte Döpa Om Kanal",
+            "busy": "Ärendet Är Upptaget"
+        },
+        "descriptions": {
+            "askForInfo": "Kontakta ägaren av denna bot för mer information!",
+            "askForInfoResolve": "Kontakta ägaren av denna bot om problemet inte löser sig efter några försök!",
+            "internalError": "Kunde inte svara på denna {0} på grund av ett internt fel!",
+            "optionMissing": "En obligatorisk parameter saknas i detta kommando!",
+            "optionInvalid": "En parameter i detta kommando är ogiltig!",
+            "optionInvalidChoose": "Välj mellan",
+            "unknownCommand": "Försök besöka hjälpmenyn för mer information!",
+            "noPermissions": "Du har inte behörighet att använda denna {0}!",
+            "noPermissionsList": "Nödvändiga behörigheter: (en av dem)",
+            "noPermissionsCooldown": "Du har inte behörighet att använda denna {0} eftersom du har en nedkylningsperiod!",
+            "noPermissionsBlacklist": "Du har inte behörighet att använda denna {0} eftersom du är svartlistad!",
+            "noPermissionsLimitGlobal": "Du har inte behörighet att skapa ett ärende eftersom servern har nått maxgränsen för ärenden!",
+            "noPermissionsLimitGlobalUser": "Du har inte behörighet att skapa ett ärende eftersom du har nått maxgränsen för ärenden!",
+            "noPermissionsLimitOption": "Du har inte behörighet att skapa ett ärende eftersom servern har nått maxgränsen för detta alternativ!",
+            "noPermissionsLimitOptionUser": "Du har inte behörighet att skapa ett ärende eftersom du har nått maxgränsen för detta alternativ!",
+            "unknownTicket": "Försök med detta kommando igen i ett giltigt ärende!",
+            "deprecatedTicket": "Den nuvarande kanalen är inte ett giltigt ärende! Det kan ha varit ett ärende från en äldre version av Open Ticket!",
+            "notInGuild": "Denna {0} fungerar inte i DM! Försök igen på en server!",
+            "channelRename": "På grund av Discords hastighetsbegränsningar är det för närvarande omöjligt för botten att döpa om kanalen. Kanalen kommer automatiskt att döpas om inom 10 minuter om botten inte startas om.",
+            "channelRenameSource": "Källan till detta fel är: {0}",
+            "busy": "Kan inte använda denna {0}!\nÄrendet behandlas för närvarande av botten.\n\nFörsök igen om några sekunder!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Värdet matchar inte mönstret!",
+            "stringMinLength": "Värdet ska vara minst {0} tecken!",
+            "stringMaxLength": "Värdet ska vara högst {0} tecken!",
+            "numberInvalid": "Ogiltigt tal!",
+            "numberMin": "Talet ska vara minst {0}!",
+            "numberMax": "Talet ska vara högst {0}!",
+            "numberDecimal": "Talet kan inte vara ett decimaltal!",
+            "numberNegative": "Talet kan inte vara negativt!",
+            "numberPositive": "Talet kan inte vara positivt!",
+            "numberZero": "Talet kan inte vara noll!",
+            "channelNotFound": "Kan inte hitta kanalen!",
+            "userNotFound": "Kan inte hitta användaren!",
+            "roleNotFound": "Kan inte hitta rollen!",
+            "memberNotFound": "Kan inte hitta användaren!",
+            "mentionableNotFound": "Kan inte hitta användaren eller rollen!",
+            "channelType": "Ogiltig kanaltyp!",
+            "notInGuild": "Detta alternativ kräver att du är på en server!"
+        },
+        "permissions": {
+            "developer": "Du måste vara utvecklaren av botten.",
+            "owner": "Du måste vara serverägaren.",
+            "admin": "Du måste vara serveradministratör.",
+            "moderator": "Du måste vara moderator.",
+            "support": "Du måste vara en del av supportteamet.",
+            "member": "Du måste vara medlem.",
+            "discord-administrator": "Du måste ha `ADMINISTRATOR`-behörigheten."
+        },
+        "actionInvalid": {
+            "close": "Ärendet är redan stängt!",
+            "reopen": "Ärendet är inte stängt ännu!",
+            "claim": "Ärendet är redan taget!",
+            "unclaim": "Ärendet är inte taget ännu!",
+            "pin": "Ärendet är redan fäst!",
+            "unpin": "Ärendet är inte fäst ännu!",
+            "add": "Denna användare har redan tillgång till ärendet!",
+            "remove": "Kan inte ta bort denna användare från ärendet!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Ärende",
+            "tickets": "Ärenden",
+            "reason": "Orsak",
+            "creator": "Skapare",
+            "remaining": "Tid Kvar",
+            "added": "Tillagd",
+            "removed": "Borttagen",
+            "filter": "Filter",
+            "claimedBy": "Taget Av {0}",
+            "method": "Metod",
+            "type": "Typ",
+            "blacklisted": "Svartlistad",
+            "panel": "Panel",
+            "command": "Kommando",
+            "system": "System",
+            "true": "Sant",
+            "false": "Falskt",
+            "syntax": "Syntax",
+            "originalName": "Ursprungligt Namn",
+            "newName": "Nytt Namn",
+            "until": "Till",
+            "validOptions": "Giltiga Alternativ",
+            "validPanels": "Giltiga Paneler",
+            "autoclose": "Autostängning",
+            "autodelete": "Autoradering",
+            "startupDate": "Startdatum",
+            "version": "Version",
+            "name": "Namn",
+            "role": "Roll",
+            "status": "Status",
+            "claimed": "Taget",
+            "pinned": "Fäst",
+            "creationDate": "Skapelsedatum"
+        },
+        "lowercase": {
+            "text": "text",
+            "html": "html",
+            "command": "kommando",
+            "modal": "modal",
+            "button": "knapp",
+            "dropdown": "rullgardinsmeny",
+            "method": "metod"
+        }
+    },
+    "commands": {
+        "reason": "Ange en valfri orsak som kommer att vara synlig i loggarna.",
+        "help": "Få en lista över alla tillgängliga kommandon.",
+        "panel": "Skapa ett meddelande med en rullgardinsmeny eller knappar (för ärendeskapande).",
+        "panelId": "Identifieraren för panelen du vill skapa.",
+        "panelAutoUpdate": "Vill du att denna panel ska uppdateras automatiskt när den redigeras?",
+        "ticket": "Skapa ett ärende direkt.",
+        "ticketId": "Identifieraren för ärendet du vill skapa.",
+        "close": "Stäng ett ärende.",
+        "delete": "Radera ett ärende.",
+        "deleteNoTranscript": "Radera detta ärende utan att skapa en utskrift.",
+        "reopen": "Återöppna ett ärende.",
+        "claim": "Ta ett ärende.",
+        "claimUser": "Ta detta ärende för en annan användare istället för dig själv.",
+        "unclaim": "Frigör ett ärende.",
+        "pin": "Fäst ett ärende.",
+        "unpin": "Lossa ett ärende.",
+        "move": "Flytta ett ärende.",
+        "moveId": "Identifieraren för alternativet du vill flytta till.",
+        "rename": "Döp om ett ärende.",
+        "renameName": "Det nya namnet på detta ärende.",
+        "add": "Lägg till en användare i ett ärende.",
+        "addUser": "Användaren som ska läggas till.",
+        "remove": "Ta bort en användare från ett ärende.",
+        "removeUser": "Användaren som ska tas bort.",
+        "blacklist": "Hantera svartlistan för ärenden.",
+        "blacklistView": "Visa en lista över nuvarande svartlista.",
+        "blacklistAdd": "Lägg till en användare på svartlistan.",
+        "blacklistRemove": "Ta bort en användare från svartlistan.",
+        "blacklistGet": "Hämta detaljer om en svartlistad användare.",
+        "blacklistGetUser": "Användaren att hämta detaljer från.",
+        "stats": "Visa statistik från botten, en användare eller ett ärende.",
+        "statsReset": "Återställ all statistik för botten (och börja räkna från noll).",
+        "statsGlobal": "Visa global statistik.",
+        "statsUser": "Visa statistik från en användare på servern.",
+        "statsUserUser": "Användaren som ska visas.",
+        "statsTicket": "Visa statistik för ett ärende på servern.",
+        "statsTicketTicket": "Ärendet som ska visas.",
+        "clear": "Radera flera ärenden samtidigt.",
+        "clearFilter": "Filtret för att radera ärenden.",
+        "clearFilters": {
+            "all": "Alla",
+            "open": "Öppna",
+            "close": "Stängda",
+            "claim": "Tagna",
+            "unclaim": "Frigjorda",
+            "pin": "Fästa",
+            "unpin": "Lossade",
+            "autoclose": "Autostängda"
+        },
+        "autoclose": "Hantera autostängning i ett ärende.",
+        "autocloseDisable": "Inaktivera autostängning i detta ärende.",
+        "autocloseEnable": "Aktivera autostängning i detta ärende.",
+        "autocloseEnableTime": "Antal timmar detta ärende måste vara inaktivt innan det stängs.",
+        "autodelete": "Hantera autoradering i ett ärende.",
+        "autodeleteDisable": "Inaktivera autoradering i detta ärende.",
+        "autodeleteEnable": "Aktivera autoradering i detta ärende.",
+        "autodeleteEnableTime": "Antal dagar detta ärende måste vara inaktivt innan det raderas."
+    },
+    "helpMenu": {
+        "help": "Få en lista över alla tillgängliga kommandon.",
+        "ticket": "Skapa ett ärende direkt.",
+        "close": "Stäng ett ärende, detta inaktiverar skrivning i kanalen.",
+        "delete": "Radera ett ärende, detta skapar en utskrift när det är aktiverat.",
+        "reopen": "Återöppna ett ärende, detta aktiverar skrivning i kanalen igen.",
+        "pin": "Fäst ett ärende. Detta flyttar ärendet till toppen och lägger till en '📌' emoji i namnet.",
+        "unpin": "Lossa ett ärende. Ärendet blir kvar på plats, men förlorar '📌' emojin.",
+        "move": "Flytta ett ärende. Detta ändrar typen på ärendet.",
+        "rename": "Döp om ett ärende. Detta ändrar kanalnamnet på ärendet.",
+        "claim": "Ta ett ärende. Detta låter ditt team veta att du hanterar ärendet.",
+        "unclaim": "Frigör ett ärende. Detta låter ditt team veta att ärendet är ledigt igen.",
+        "add": "Lägg till en användare i ett ärende. Detta ger användaren tillgång att läsa och skriva i ärendet.",
+        "remove": "Ta bort en användare från ett ärende. Detta tar bort användarens tillgång att läsa och skriva i ärendet.",
+        "panel": "Skapa ett meddelande med en rullgardinsmeny eller knappar (för ärendeskapande).",
+        "blacklistView": "Visa en lista över nuvarande svartlista.",
+        "blacklistAdd": "Lägg till en användare på svartlistan.",
+        "blacklistRemove": "Ta bort en användare från svartlistan.",
+        "blacklistGet": "Hämta detaljer om en svartlistad användare.",
+        "statsGlobal": "Visa global statistik.",
+        "statsTicket": "Visa statistik för ett ärende på servern.",
+        "statsUser": "Visa statistik från en användare på servern.",
+        "statsReset": "Återställ all statistik för botten (och börja räkna från noll).",
+        "autocloseDisable": "Inaktivera autostängning i detta ärende.",
+        "autocloseEnable": "Aktivera autostängning i detta ärende.",
+        "autodeleteDisable": "Inaktivera autoradering i detta ärende.",
+        "autodeleteEnable": "Aktivera autoradering i detta ärende."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Global Statistik",
+            "system": "Systemstatistik",
+            "user": "Användarstatistik",
+            "ticket": "Ärendestatistik",
+            "participants": "Deltagare"
+        },
+        "properties": {
+            "ticketsCreated": "Ärenden Skapade",
+            "ticketsClosed": "Ärenden Stängda",
+            "ticketsDeleted": "Ärenden Raderade",
+            "ticketsReopened": "Ärenden Återöppnade",
+            "ticketsAutoclosed": "Ärenden Autostängda",
+            "ticketsClaimed": "Ärenden Tagna",
+            "ticketsPinned": "Ärenden Fästa",
+            "ticketsMoved": "Ärenden Flyttade",
+            "usersBlacklisted": "Användare Svartlistade",
+            "transcriptsCreated": "Utskrifter Skapade"
+        }
+    }
+}
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["modshd"],
        "lastedited":"13/11/2024",
        "language":"Thai",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION": {
-        "otversion": "v4.0.0",
+        "otversion": "v4.0.4",
        "translators": ["palestinian"],
        "lastedited": "26/11/2024",
        "language": "Turkish",
@@ -1,6 +1,6 @@
 {
    "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.4",
        "translators":["Anderskiy"],
        "lastedited":"31/08/2024",
        "language":"Ukrainian",
@@ -0,0 +1,466 @@
+{
+    "_TRANSLATION":{
+        "otversion":"v4.0.4",
+        "translators":["ngocdiep2006"],
+        "lastedited":"07/04/2025",
+        "language":"Vietnamese",
+        "automated":true
+    },
+    "checker":{
+        "system":{
+            "typeError":"[ERROR]",
+            "headerOpenTicket":"OPEN TICKET",
+            "typeWarning":"[WARNING]",
+            "typeInfo":"[INFO]",
+            "headerConfigChecker":"CONFIG CHECKER",
+            "headerDescription":"check for errors in your config files!",
+            "footerError":"the bot won't start until all {0}'s are fixed!",
+            "footerWarning":"it's recommended to fix all {0}'s before starting!",
+            "footerSupport":"SUPPORT: {0} - DOCS: {1}",
+            "compactInformation":"use {0} for more information!",
+            "dataPath":"path",
+            "dataDocs":"docs",
+            "dataMessages":"message"
+        },
+       "messages": {
+            "stringTooShort": "Chuỗi này không thể ngắn hơn {0} ký tự!",
+            "stringTooLong": "Chuỗi này không thể dài hơn {0} ký tự!",
+            "stringLengthInvalid": "Chuỗi này cần dài {0} ký tự!",
+            "stringStartsWith": "Chuỗi này cần bắt đầu bằng {0}!",
+            "stringEndsWith": "Chuỗi này cần kết thúc bằng {0}!",
+            "stringContains": "Chuỗi này cần chứa {0}!",
+            "stringChoices": "Chuỗi này chỉ có thể là một trong các giá trị sau: {0}!",
+            "stringRegex": "Chuỗi này không hợp lệ!",
+            "numberTooShort": "Số này không thể ngắn hơn {0} ký tự!",
+            "numberTooLong": "Số này không thể dài hơn {0} ký tự!",
+            "numberLengthInvalid": "Số này cần dài {0} ký tự!",
+            "numberTooSmall": "Số này cần ít nhất là {0}!",
+            "numberTooLarge": "Số này cần nhiều nhất là {0}!",
+            "numberNotEqual": "Số này cần là {0}!",
+            "numberStep": "Số này cần là bội số của {0}!",
+            "numberStepOffset": "Số này cần là bội số của {0} bắt đầu từ {1}!",
+            "numberStartsWith": "Số này cần bắt đầu bằng {0}!",
+            "numberEndsWith": "Số này cần kết thúc bằng {0}!",
+            "numberContains": "Số này cần chứa {0}!",
+            "numberChoices": "Số này chỉ có thể là một trong các giá trị sau: {0}!",
+            "numberFloat": "Số này không thể là số thập phân!",
+            "numberNegative": "Số này không thể là số âm!",
+            "numberPositive": "Số này không thể là số dương!",
+            "numberZero": "Số này không thể là số không!",
+            "booleanTrue": "Boolean này không thể là true!",
+            "booleanFalse": "Boolean này không thể là false!",
+            "arrayEmptyDisabled": "Mảng này không được phép rỗng!",
+            "arrayEmptyRequired": "Mảng này bắt buộc phải rỗng!",
+            "arrayTooShort": "Mảng này cần có độ dài ít nhất là {0}!",
+            "arrayTooLong": "Mảng này cần có độ dài nhiều nhất là {0}!",
+            "arrayLengthInvalid": "Mảng này cần có độ dài là {0}!",
+            "arrayInvalidTypes": "Mảng này chỉ có thể chứa các kiểu sau: {0}!",
+            "arrayDouble": "Mảng này không cho phép giá trị trùng lặp!",
+            "discordInvalidId": "Đây là id discord {0} không hợp lệ!",
+            "discordInvalidIdOptions": "Đây là id discord {0} không hợp lệ! Bạn cũng có thể sử dụng một trong những id sau: {1}!",
+            "discordInvalidToken": "Đây là token discord không hợp lệ (về mặt cú pháp)!",
+            "colorInvalid": "Đây là màu hex không hợp lệ!",
+            "emojiTooShort": "Chuỗi này cần có ít nhất {0} emoji!",
+            "emojiTooLong": "Chuỗi này cần có nhiều nhất {0} emoji!",
+            "emojiCustom": "Emoji này không thể là emoji discord tùy chỉnh!",
+            "emojiInvalid": "Đây là emoji không hợp lệ!",
+            "urlInvalid": "URL này không hợp lệ!",
+            "urlInvalidHttp": "URL này chỉ có thể sử dụng giao thức https://!",
+            "urlInvalidProtocol": "URL này chỉ có thể sử dụng giao thức http:// & https://!",
+            "urlInvalidHostname": "URL này có tên máy chủ bị cấm!",
+            "urlInvalidExtension": "URL này có phần mở rộng không hợp lệ! Chọn trong số: {0}!",
+            "urlInvalidPath": "URL này có đường dẫn không hợp lệ!",
+            "idNotUnique": "ID này không duy nhất, hãy sử dụng ID khác!",
+            "idNonExistent": "ID {0} không tồn tại!",
+            "invalidType": "Thuộc tính này cần có kiểu: {0}!",
+            "propertyMissing": "Thuộc tính {0} bị thiếu trong đối tượng này!",
+            "propertyOptional": "Thuộc tính {0} là tùy chọn trong đối tượng này!",
+            "objectDisabled": "Đối tượng này bị tắt, hãy bật nó bằng cách sử dụng {0}!",
+            "nullInvalid": "Thuộc tính này không thể là null!",
+            "switchInvalidType": "Điều này cần là một trong các kiểu sau: {0}!",
+            "objectSwitchInvalid": "Đối tượng này cần là một trong các kiểu sau: {0}!",
+            "invalidLanguage": "Đây là ngôn ngữ không hợp lệ!",
+            "invalidButton": "Nút này cần có ít nhất một {0} hoặc {1}!",
+            "unusedOption": "Tùy chọn {0} không được sử dụng ở bất kỳ đâu!",
+            "unusedQuestion": "Câu hỏi {0} không được sử dụng ở bất kỳ đâu!",
+            "dropdownOption": "Bảng điều khiển có bật dropdown chỉ có thể chứa các tùy chọn thuộc loại 'ticket'!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Truy cập Ticket",
+            "close": "Đóng Ticket",
+            "delete": "Xóa Ticket",
+            "reopen": "Mở lại Ticket",
+            "claim": "Nhận Ticket",
+            "unclaim": "Bỏ nhận Ticket",
+            "pin": "Ghim Ticket",
+            "unpin": "Bỏ ghim Ticket",
+            "clear": "Xóa Tickets",
+            "helpSwitchSlash": "Xem Lệnh Slash",
+            "helpSwitchText": "Xem Lệnh Văn Bản",
+            "helpPage": "Trang {0}",
+            "withReason": "Có Lý Do",
+            "withoutTranscript": "Không Có Bản Ghi"
+        },
+        "titles": {
+            "created": "Ticket Đã Tạo",
+            "close": "Ticket Đã Đóng",
+            "delete": "Ticket Đã Xóa",
+            "reopen": "Ticket Đã Mở Lại",
+            "claim": "Ticket Đã Nhận",
+            "unclaim": "Ticket Đã Bỏ Nhận",
+            "pin": "Ticket Đã Ghim",
+            "unpin": "Ticket Đã Bỏ Ghim",
+            "rename": "Ticket Đã Đổi Tên",
+            "move": "Ticket Đã Di Chuyển",
+            "add": "Người Dùng Đã Thêm Vào Ticket",
+            "remove": "Người Dùng Đã Xóa Khỏi Ticket",
+            "help": "Lệnh Có Sẵn",
+            "statsReset": "Đặt Lại Thống Kê",
+            "blacklistAdd": "Người Dùng Đã Bị Cấm",
+            "blacklistRemove": "Người Dùng Đã Được Gỡ Cấm",
+            "blacklistGet": "Người Dùng Bị Cấm",
+            "blacklistView": "Danh Sách Cấm Hiện Tại",
+            "blacklistAddDm": "Đã Thêm Vào Danh Sách Cấm",
+            "blacklistRemoveDm": "Đã Xóa Khỏi Danh Sách Cấm",
+            "clear": "Tickets Đã Xóa",
+            "roles": "Vai Trò Đã Cập Nhật",
+            "autoclose": "Ticket Tự Động Đóng",
+            "autocloseEnabled": "Tự Động Đóng Đã Bật",
+            "autocloseDisabled": "Tự Động Đóng Đã Tắt",
+            "autodelete": "Ticket Tự Động Xóa",
+            "autodeleteEnabled": "Tự Động Xóa Đã Bật",
+            "autodeleteDisabled": "Tự Động Xóa Đã Tắt"
+        },
+        "descriptions": {
+            "create": "Ticket của bạn đã được tạo. Nhấp vào nút bên dưới để truy cập!",
+            "close": "Ticket đã được đóng thành công!",
+            "delete": "Ticket đã được xóa thành công!",
+            "reopen": "Ticket đã được mở lại thành công!",
+            "claim": "Ticket đã được nhận thành công!",
+            "unclaim": "Ticket đã được bỏ nhận thành công!",
+            "pin": "Ticket đã được ghim thành công!",
+            "unpin": "Ticket đã được bỏ ghim thành công!",
+            "rename": "Ticket đã được đổi tên thành {0} thành công!",
+            "move": "Ticket đã được di chuyển đến {0} thành công!",
+            "add": "{0} đã được thêm vào ticket thành công!",
+            "remove": "{0} đã được xóa khỏi ticket thành công!",
+            "helpExplanation": "`<name>` => tham số bắt buộc\n`[name]` => tham số tùy chọn",
+            "statsReset": "Thống kê bot đã được đặt lại thành công!",
+            "statsError": "Không thể xem thống kê ticket!\n{0} không phải là ticket!",
+            "blacklistAdd": "{0} đã bị cấm thành công!",
+            "blacklistRemove": "{0} đã được gỡ cấm thành công!",
+            "blacklistGetSuccess": "{0} hiện đang bị cấm!",
+            "blacklistGetEmpty": "{0} hiện không bị cấm!",
+            "blacklistViewEmpty": "Chưa có ai bị cấm!",
+            "blacklistViewTip": "Sử dụng \"/blacklist add\" để cấm người dùng!",
+            "clearVerify": "Bạn có chắc chắn muốn xóa nhiều ticket không?\nHành động này không thể hoàn tác!",
+            "clearReady": "{0} tickets đã được xóa thành công!",
+            "rolesEmpty": "Không có vai trò nào được cập nhật!",
+            "autocloseLeave": "Ticket này đã được tự động đóng vì người tạo đã rời khỏi máy chủ!",
+            "autocloseTimeout": "Ticket này đã được tự động đóng vì không hoạt động quá `{0}h`!",
+            "autodeleteLeave": "Ticket này đã được tự động xóa vì người tạo đã rời khỏi máy chủ!",
+            "autodeleteTimeout": "Ticket này đã được tự động xóa vì không hoạt động quá `{0} ngày`!",
+            "autocloseEnabled": "Tự động đóng đã được bật trong ticket này!\nNó sẽ được đóng khi không hoạt động quá `{0}h`!",
+            "autocloseDisabled": "Tự động đóng đã được tắt trong ticket này!\nNó sẽ không tự động đóng nữa!",
+            "autodeleteEnabled": "Tự động xóa đã được bật trong ticket này!\nNó sẽ được xóa khi không hoạt động quá `{0} ngày`!",
+            "autodeleteDisabled": "Tự động xóa đã được tắt trong ticket này!\nNó sẽ không tự động xóa nữa!",
+            "ticketMessageLimit": "Bạn chỉ có thể tạo {0} ticket cùng lúc!",
+            "ticketMessageAutoclose": "Ticket này sẽ được tự động đóng khi không hoạt động trong {0}h!",
+            "ticketMessageAutodelete": "Ticket này sẽ được tự động xóa khi không hoạt động trong {0} ngày!",
+            "panelReady": "Bạn có thể tìm thấy bảng điều khiển bên dưới!\nThông báo này có thể được xóa ngay bây giờ!"
+        }
+,
+        "modal": {
+            "closePlaceholder": "Tại sao bạn đóng ticket này?",
+            "deletePlaceholder": "Tại sao bạn xóa ticket này?",
+            "reopenPlaceholder": "Tại sao bạn mở lại ticket này?",
+            "claimPlaceholder": "Tại sao bạn nhận ticket này?",
+            "unclaimPlaceholder": "Tại sao bạn bỏ nhận ticket này?",
+            "pinPlaceholder": "Tại sao bạn ghim ticket này?",
+            "unpinPlaceholder": "Tại sao bạn bỏ ghim ticket này?"
+        },
+        "logs": {
+            "createLog": "Một ticket mới đã được tạo bởi {0}!",
+            "closeLog": "Ticket này đã được đóng bởi {0}!",
+            "closeDm": "Ticket của bạn đã được đóng trong máy chủ của chúng tôi!",
+            "deleteLog": "Ticket này đã được xóa bởi {0}!",
+            "deleteDm": "Ticket của bạn đã được xóa trong máy chủ của chúng tôi!",
+            "reopenLog": "Ticket này đã được mở lại bởi {0}!",
+            "reopenDm": "Ticket của bạn đã được mở lại trong máy chủ của chúng tôi!",
+            "claimLog": "Ticket này đã được nhận bởi {0}!",
+            "claimDm": "Ticket của bạn đã được nhận trong máy chủ của chúng tôi!",
+            "unclaimLog": "Ticket này đã được bỏ nhận bởi {0}!",
+            "unclaimDm": "Ticket của bạn đã được bỏ nhận trong máy chủ của chúng tôi!",
+            "pinLog": "Ticket này đã được ghim bởi {0}!",
+            "pinDm": "Ticket của bạn đã được ghim trong máy chủ của chúng tôi!",
+            "unpinLog": "Ticket này đã được bỏ ghim bởi {0}!",
+            "unpinDm": "Ticket của bạn đã được bỏ ghim trong máy chủ của chúng tôi!",
+            "renameLog": "Ticket này đã được đổi tên thành {0} bởi {1}!",
+            "renameDm": "Ticket của bạn đã được đổi tên thành {0} trong máy chủ của chúng tôi!",
+            "moveLog": "Ticket này đã được di chuyển đến {0} bởi {1}!",
+            "moveDm": "Ticket của bạn đã được di chuyển đến {0} trong máy chủ của chúng tôi!",
+            "addLog": "{0} đã được thêm vào ticket này bởi {1}!",
+            "addDm": "{0} đã được thêm vào ticket của bạn trong máy chủ của chúng tôi!",
+            "removeLog": "{0} đã được xóa khỏi ticket này bởi {1}!",
+            "removeDm": "{0} đã được xóa khỏi ticket của bạn trong máy chủ của chúng tôi!",
+            "blacklistAddLog": "{0} đã bị cấm bởi {1}!",
+            "blacklistRemoveLog": "{0} đã được gỡ khỏi danh sách cấm bởi {1}!",
+            "blacklistAddDm": "Bạn đã bị cấm trong máy chủ của chúng tôi!\nTừ bây giờ, bạn không thể tạo ticket!",
+            "blacklistRemoveDm": "Bạn đã được gỡ khỏi danh sách cấm trong máy chủ của chúng tôi!\nBây giờ bạn có thể tạo lại ticket!",
+            "clearLog": "{0} tickets đã được xóa bởi {1}!"
+        }
+    },
+    "transcripts": {
+        "success": {
+            "visit": "Truy Cập Bản Ghi",
+            "ready": "Bản Ghi Đã Tạo",
+            "textFileDescription": "Đây là bản ghi văn bản của một ticket đã xóa!",
+            "htmlProgress": "Vui lòng đợi trong khi bản ghi html này đang được xử lý...",
+            "createdChannel": "Một bản ghi {0} mới đã được tạo trong máy chủ!",
+            "createdCreator": "Một bản ghi {0} mới đã được tạo cho một trong các ticket của bạn!",
+            "createdParticipant": "Một bản ghi {0} mới đã được tạo trong một trong các ticket bạn tham gia!",
+            "createdActiveAdmin": "Một bản ghi {0} mới đã được tạo trong một trong các ticket bạn tham gia với tư cách quản trị viên!",
+            "createdEveryAdmin": "Một bản ghi {0} mới đã được tạo trong một trong các ticket bạn là quản trị viên!",
+            "createdOther": "Một bản ghi {0} mới đã được tạo!"
+        },
+        "errors": {
+            "retry": "Thử Lại",
+            "continue": "Xóa Không Có Bản Ghi",
+            "backup": "Tạo Bản Ghi Dự Phòng",
+            "error": "Đã xảy ra lỗi khi cố gắng tạo bản ghi.\nBạn muốn làm gì?\n\nTicket này sẽ không bị xóa cho đến khi bạn nhấp vào một trong các nút này."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Lỗi Nội Bộ",
+            "optionMissing": "Thiếu Tùy Chọn Lệnh",
+            "optionInvalid": "Tùy Chọn Lệnh Không Hợp Lệ",
+            "unknownCommand": "Lệnh Không Xác Định",
+            "noPermissions": "Không Có Quyền",
+            "unknownTicket": "Ticket Không Xác Định",
+            "deprecatedTicket": "Ticket Đã Lỗi Thời",
+            "unknownOption": "Tùy Chọn Không Xác Định",
+            "unknownPanel": "Bảng Điều Khiển Không Xác Định",
+            "notInGuild": "Không Ở Trong Máy Chủ",
+            "channelRename": "Không Thể Đổi Tên Kênh",
+            "busy": "Ticket Đang Bận"
+        },
+        "descriptions": {
+            "askForInfo": "Liên hệ với chủ sở hữu của bot này để biết thêm thông tin!",
+            "askForInfoResolve": "Liên hệ với chủ sở hữu bot này nếu vấn đề này không được giải quyết sau vài lần thử.",
+            "internalError": "Không thể phản hồi {0} này do lỗi nội bộ!",
+            "optionMissing": "Thiếu tham số bắt buộc trong lệnh này!",
+            "optionInvalid": "Tham số trong lệnh này không hợp lệ!",
+            "optionInvalidChoose": "Chọn trong số",
+            "unknownCommand": "Hãy thử truy cập menu trợ giúp để biết thêm thông tin!",
+            "noPermissions": "Bạn không được phép sử dụng {0} này!",
+            "noPermissionsList": "Quyền Bắt Buộc: (một trong số chúng)",
+            "noPermissionsCooldown": "Bạn không được phép sử dụng {0} này vì bạn đang trong thời gian chờ!",
+            "noPermissionsBlacklist": "Bạn không được phép sử dụng {0} này vì bạn đã bị cấm!",
+            "noPermissionsLimitGlobal": "Bạn không được phép tạo ticket vì máy chủ đã đạt đến giới hạn ticket tối đa!",
+            "noPermissionsLimitGlobalUser": "Bạn không được phép tạo ticket vì bạn đã đạt đến giới hạn ticket tối đa!",
+            "noPermissionsLimitOption": "Bạn không được phép tạo ticket vì máy chủ đã đạt đến giới hạn ticket tối đa cho tùy chọn này!",
+            "noPermissionsLimitOptionUser": "Bạn không được phép tạo ticket vì bạn đã đạt đến giới hạn ticket tối đa cho tùy chọn này!",
+            "unknownTicket": "Hãy thử lại lệnh này trong một ticket hợp lệ!",
+            "deprecatedTicket": "Kênh hiện tại không phải là ticket hợp lệ! Nó có thể là một ticket từ phiên bản Open Ticket cũ!",
+            "notInGuild": "{0} này không hoạt động trong DM! Vui lòng thử lại trong máy chủ!",
+            "channelRename": "Do giới hạn tốc độ của discord, hiện tại bot không thể đổi tên kênh. Kênh sẽ tự động được đổi tên trong 10 phút nếu bot không được khởi động lại.",
+            "channelRenameSource": "Nguồn gốc của lỗi này là: {0}",
+            "busy": "Không thể sử dụng {0} này!\nTicket hiện đang được bot xử lý.\n\nVui lòng thử lại sau vài giây!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Giá trị không khớp với mẫu!",
+            "stringMinLength": "Giá trị cần có ít nhất {0} ký tự!",
+            "stringMaxLength": "Giá trị cần có nhiều nhất {0} ký tự!",
+            "numberInvalid": "Số không hợp lệ!",
+            "numberMin": "Số cần ít nhất là {0}!",
+            "numberMax": "Số cần nhiều nhất là {0}!",
+            "numberDecimal": "Số không được phép là số thập phân!",
+            "numberNegative": "Số không được phép là số âm!",
+            "numberPositive": "Số không được phép là số dương!",
+            "numberZero": "Số không được phép là số không!",
+            "channelNotFound": "Không thể tìm thấy kênh!",
+            "userNotFound": "Không thể tìm thấy người dùng!",
+            "roleNotFound": "Không thể tìm thấy vai trò!",
+            "memberNotFound": "Không thể tìm thấy người dùng!",
+            "mentionableNotFound": "Không thể tìm thấy người dùng hoặc vai trò!",
+            "channelType": "Loại kênh không hợp lệ!",
+            "notInGuild": "Tùy chọn này yêu cầu bạn phải ở trong máy chủ!"
+        },
+        "permissions": {
+            "developer": "Bạn cần là nhà phát triển của bot.",
+            "owner": "Bạn cần là chủ sở hữu máy chủ.",
+            "admin": "Bạn cần là quản trị viên máy chủ.",
+            "moderator": "Bạn cần là người điều hành.",
+            "support": "Bạn cần ở trong nhóm hỗ trợ.",
+            "member": "Bạn cần là thành viên.",
+            "discord-administrator": "Bạn cần có quyền `ADMINISTRATOR`."
+        },
+        "actionInvalid": {
+            "close": "Ticket đã đóng!",
+            "reopen": "Ticket chưa đóng!",
+            "claim": "Ticket đã được nhận!",
+            "unclaim": "Ticket chưa được nhận!",
+            "pin": "Ticket đã được ghim!",
+            "unpin": "Ticket chưa được ghim!",
+            "add": "Người dùng này đã có thể truy cập ticket!",
+            "remove": "Không thể xóa người dùng này khỏi ticket!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Ticket",
+            "tickets": "Tickets",
+            "reason": "Lý Do",
+            "creator": "Người Tạo",
+            "remaining": "Thời Gian Còn Lại",
+            "added": "Đã Thêm",
+            "removed": "Đã Xóa",
+            "filter": "Bộ Lọc",
+            "claimedBy": "Được Nhận Bởi {0}",
+            "method": "Phương Pháp",
+            "type": "Loại",
+            "blacklisted": "Bị Cấm",
+            "panel": "Bảng Điều Khiển",
+            "command": "Lệnh",
+            "system": "Hệ Thống",
+            "true": "Đúng",
+            "false": "Sai",
+            "syntax": "Cú Pháp",
+            "originalName": "Tên Gốc",
+            "newName": "Tên Mới",
+            "until": "Đến",
+            "validOptions": "Tùy Chọn Hợp Lệ",
+            "validPanels": "Bảng Điều Khiển Hợp Lệ",
+            "autoclose": "Tự Động Đóng",
+            "autodelete": "Tự Động Xóa",
+            "startupDate": "Ngày Khởi Động",
+            "version": "Phiên Bản",
+            "name": "Tên",
+            "role": "Vai Trò",
+            "status": "Trạng Thái",
+            "claimed": "Đã Nhận",
+            "pinned": "Đã Ghim",
+            "creationDate": "Ngày Tạo"
+        },
+        "lowercase": {
+            "text": "văn bản",
+            "html": "html",
+            "command": "lệnh",
+            "modal": "modal",
+            "button": "nút",
+            "dropdown": "dropdown",
+            "method": "phương pháp"
+        }
+    },
+    "commands": {
+        "reason": "Chỉ định lý do tùy chọn sẽ hiển thị trong nhật ký.",
+        "help": "Nhận danh sách tất cả các lệnh có sẵn.",
+        "panel": "Tạo thông báo có dropdown hoặc nút (để tạo ticket).",
+        "panelId": "Mã định danh của bảng điều khiển bạn muốn tạo.",
+        "panelAutoUpdate": "Bạn có muốn bảng điều khiển này tự động cập nhật khi được chỉnh sửa không?",
+        "ticket": "Tạo ticket ngay lập tức.",
+        "ticketId": "Mã định danh của ticket bạn muốn tạo.",
+        "close": "Đóng ticket.",
+        "delete": "Xóa ticket.",
+        "deleteNoTranscript": "Xóa ticket này mà không tạo bản ghi.",
+        "reopen": "Mở lại ticket.",
+        "claim": "Nhận ticket.",
+        "claimUser": "Nhận ticket này cho người khác thay vì chính bạn.",
+        "unclaim": "Bỏ nhận ticket.",
+        "pin": "Ghim ticket.",
+        "unpin": "Bỏ ghim ticket.",
+        "move": "Di chuyển ticket.",
+        "moveId": "Mã định danh của tùy chọn bạn muốn di chuyển đến.",
+        "rename": "Đổi tên ticket.",
+        "renameName": "Tên mới cho ticket này.",
+        "add": "Thêm người dùng vào ticket.",
+        "addUser": "Người dùng cần thêm.",
+        "remove": "Xóa người dùng khỏi ticket.",
+        "removeUser": "Người dùng cần xóa.",
+        "blacklist": "Quản lý danh sách cấm ticket.",
+        "blacklistView": "Xem danh sách cấm hiện tại.",
+        "blacklistAdd": "Thêm người dùng vào danh sách cấm.",
+        "blacklistRemove": "Xóa người dùng khỏi danh sách cấm.",
+        "blacklistGet": "Nhận thông tin chi tiết từ người dùng bị cấm.",
+        "blacklistGetUser": "Người dùng cần nhận thông tin chi tiết.",
+        "stats": "Xem thống kê từ bot, thành viên hoặc ticket.",
+        "statsReset": "Đặt lại tất cả thống kê của bot (và bắt đầu đếm từ không).",
+        "statsGlobal": "Xem thống kê toàn cầu.",
+        "statsUser": "Xem thống kê từ người dùng trong máy chủ.",
+        "statsUserUser": "Người dùng cần xem.",
+        "statsTicket": "Xem thống kê của ticket trong máy chủ.",
+        "statsTicketTicket": "Ticket cần xem.",
+        "clear": "Xóa nhiều ticket cùng lúc.",
+        "clearFilter": "Bộ lọc để xóa ticket.",
+        "clearFilters": {
+            "all": "Tất Cả",
+            "open": "Mở",
+            "close": "Đã Đóng",
+            "claim": "Đã Nhận",
+            "unclaim": "Chưa Nhận",
+            "pin": "Đã Ghim",
+            "unpin": "Chưa Ghim",
+            "autoclose": "Tự Động Đóng"
+        },
+        "autoclose": "Quản lý tự động đóng trong ticket.",
+        "autocloseDisable": "Tắt tự động đóng trong ticket này.",
+        "autocloseEnable": "Bật tự động đóng trong ticket này.",
+        "autocloseEnableTime": "Số giờ ticket này cần không hoạt động để đóng.",
+        "autodelete": "Quản lý tự động xóa trong ticket.",
+        "autodeleteDisable": "Tắt tự động xóa trong ticket này.",
+        "autodeleteEnable": "Bật tự động xóa trong ticket này.",
+        "autodeleteEnableTime": "Số ngày ticket này cần không hoạt động để xóa."
+    },
+    "helpMenu": {
+        "help": "Nhận danh sách tất cả các lệnh có sẵn.",
+        "ticket": "Tạo ticket ngay lập tức.",
+        "close": "Đóng ticket, điều này vô hiệu hóa việc viết trong kênh này.",
+        "delete": "Xóa ticket, điều này tạo bản ghi khi được bật.",
+        "reopen": "Mở lại ticket, điều này cho phép viết lại trong kênh này.",
+        "pin": "Ghim ticket. Điều này sẽ di chuyển ticket lên đầu và thêm biểu tượng cảm xúc '📌' vào tên.",
+        "unpin": "Bỏ ghim ticket. Ticket sẽ giữ nguyên vị trí nhưng sẽ mất biểu tượng cảm xúc '📌'.",
+        "move": "Di chuyển ticket. Điều này sẽ thay đổi loại ticket này.",
+        "rename": "Đổi tên ticket. Điều này sẽ thay đổi tên kênh của ticket này.",
+        "claim": "Nhận ticket. Với điều này, bạn có thể cho nhóm của mình biết bạn đang xử lý ticket này.",
+        "unclaim": "Bỏ nhận ticket. Với điều này, bạn có thể cho nhóm của mình biết rằng ticket này lại rảnh.",
+        "add": "Thêm người dùng vào ticket. Điều này sẽ cho phép người dùng đọc và viết trong ticket này.",
+        "remove": "Xóa người dùng khỏi ticket. Điều này sẽ xóa khả năng đọc và viết của người dùng trong ticket này.",
+        "panel": "Tạo thông báo có dropdown hoặc nút (để tạo ticket).",
+        "blacklistView": "Xem danh sách cấm hiện tại.",
+        "blacklistAdd": "Thêm người dùng vào danh sách cấm.",
+        "blacklistRemove": "Xóa người dùng khỏi danh sách cấm.",
+        "blacklistGet": "Nhận thông tin chi tiết từ người dùng bị cấm.",
+        "statsGlobal": "Xem thống kê toàn cầu.",
+        "statsTicket": "Xem thống kê của ticket trong máy chủ.",
+        "statsUser": "Xem thống kê từ người dùng trong máy chủ.",
+        "statsReset": "Đặt lại tất cả thống kê của bot (và bắt đầu đếm từ không).",
+        "autocloseDisable": "Tắt tự động đóng trong ticket này.",
+        "autocloseEnable": "Bật tự động đóng trong ticket này.",
+        "autodeleteDisable": "Tắt tự động xóa trong ticket này.",
+        "autodeleteEnable": "Bật tự động xóa trong ticket này."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Thống Kê Toàn Cầu",
+            "system": "Thống Kê Hệ Thống",
+            "user": "Thống Kê Người Dùng",
+            "ticket": "Thống Kê Ticket",
+            "participants": "Người Tham Gia"
+        },
+        "properties": {
+            "ticketsCreated": "Tickets Đã Tạo",
+            "ticketsClosed": "Tickets Đã Đóng",
+            "ticketsDeleted": "Tickets Đã Xóa",
+            "ticketsReopened": "Tickets Đã Mở Lại",
+            "ticketsAutoclosed": "Tickets Tự Động Đóng",
+            "ticketsClaimed": "Tickets Đã Nhận",
+            "ticketsPinned": "Tickets Đã Ghim",
+            "ticketsMoved": "Tickets Đã Di Chuyển",
+            "usersBlacklisted": "Người Dùng Bị Cấm",
+            "transcriptsCreated": "Bản Ghi Đã Tạo"
+        }
+    }
+}
@@ -1,7 +1,7 @@
 {
    "name": "open-ticket",
    "author": "DJdj Development",
-    "version": "4.0.0",
+    "version": "4.0.4",
    "description": "The most advanced open-source discord ticket bot with HTML transcripts, plugins, questions, claiming, pinning & more! Using discord.js v14 & JSON database! ",
    "keywords": [
        "ticket-bot",
@@ -16,7 +16,8 @@
        "start": "node index.js",
        "startnc": "node index.js --no-compile",
        "test": "node index.js --dev-config --dev-database",
-        "testnc": "node index.js --no-compile --dev-config --dev-database"
+        "testnc": "node index.js --no-compile --dev-config --dev-database",
+        "docs": "npx typedoc --options .docs/typedoc-config.json && node .docs/createDocs.js"
    },
    "type": "commonjs",
    "license": "GPL-3.0-only",
@@ -24,16 +25,16 @@
        "@discordjs/rest": "^2.4.2",
        "@types/node": "^22.5.0",
        "ansis": "^2.3.0",
-        "discord.js": "^14.17.2",
+        "discord.js": "^14.19.1",
        "formatted-json-stringify": "^1.1.0",
        "typescript": "^5.5.4"
    },
    "repository": {
        "type": "git",
-        "url": "git+https://github.com/DJj123dj/open-ticket.git"
+        "url": "git+https://github.com/open-discord-bots/open-ticket.git"
    },
    "bugs": {
-        "url": "https://github.com/DJj123dj/open-ticket/issues",
+        "url": "https://github.com/open-discord-bots/open-ticket/issues",
        "email": "support@dj-dj.be"
    },
    "homepage": "https://openticket.dj-dj.be",
@@ -41,7 +42,7 @@
        "#opendiscord": "./dist/src/index.js",
        "#opendiscord-types": "./dist/src/core/api/api.js"
    },
-    "funding":{
+    "funding": {
        "type": "individual",
        "url": "https://github.com/sponsors/DJj123dj"
    }
@@ -1,4 +1,4 @@
-import {api, openticket, utilities} from "#opendiscord"
+import {api, opendiscord, utilities} from "#opendiscord"
 import * as discord from "discord.js"

 /////////////////////////////////////////////
@@ -19,7 +19,7 @@ declare module "#opendiscord-types" {
 }

 //Let's register the example config. This way it's available for all plugins & systems.
-openticket.events.get("onConfigLoad").listen((configManager) => {
+opendiscord.events.get("onConfigLoad").listen((configManager) => {
    configManager.add(new api.ODJsonConfig("example-plugin:config","config.json","./plugins/example-plugin/"))
    /*===== What did we do? =====
    - "example-plugin:config" Is the ID of this config. You can use this id troughout the bot to access this config file. Even in other plugins.
@@ -29,18 +29,18 @@ openticket.events.get("onConfigLoad").listen((configManager) => {

    //Let's also log it to the console to let us know it worked!
    const ourConfig = configManager.get("example-plugin:config")
-    openticket.log("The example config loaded successfully!","plugin",[
+    opendiscord.log("The example config loaded successfully!","plugin",[
        {key:"var-1",value:ourConfig.data.testVariable1},
        {key:"var-2",value:ourConfig.data.testVariable2.toString()},
        {key:"var-3",value:ourConfig.data.testVariable3.toString()}
    ])
 })

-openticket.events.get("onTicketCreate").listen((creator) => {
+opendiscord.events.get("onTicketCreate").listen((creator) => {
    //This is logged before the ticket is created (after the button is pressed)
-    openticket.log("Ticket is getting created...","plugin")
+    opendiscord.log("Ticket is getting created...","plugin")
 })
-openticket.events.get("afterTicketCreated").listen((ticket,creator,channel) => {
+opendiscord.events.get("afterTicketCreated").listen((ticket,creator,channel) => {
    //This is logged after the ticket is created
-    openticket.log("Ticket ready!","plugin")
+    opendiscord.log("Ticket ready!","plugin")
 })
@@ -1,24 +1,24 @@
 ///////////////////////////////////////
 //TICKET ADD USER SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:add-ticket-user"))
-    openticket.actions.get("openticket:add-ticket-user").workers.add([
-        new api.ODWorker("openticket:add-ticket-user",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:add-ticket-user"))
+    opendiscord.actions.get("opendiscord:add-ticket-user").workers.add([
+        new api.ODWorker("opendiscord:add-ticket-user",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to add user to ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketUserAdd").emit([ticket,user,data,channel,reason])
+            await opendiscord.events.get("onTicketUserAdd").emit([ticket,user,data,channel,reason])
            
            //update ticket
-            ticket.get("openticket:participants").value.push({type:"user",id:data.id})
-            ticket.get("openticket:participants").refreshDatabase()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:participants").value.push({type:"user",id:data.id})
+            ticket.get("opendiscord:participants").refreshDatabase()
+            ticket.get("opendiscord:busy").value = true

            //update channel permissions
            try{
@@ -31,47 +31,47 @@ export const registerActions = async () => {
                    ReadMessageHistory:true
                })
            }catch{
-                openticket.log("Failed to add channel permission overwrites on add-ticket-user","error")
+                opendiscord.log("Failed to add channel permission overwrites on add-ticket-user","error")
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket user adding!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket user adding!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value,hidden:true}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:add-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketUserAdded").emit([ticket,user,data,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:add-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketUserAdded").emit([ticket,user,data,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.adding.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.adding.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.adding.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket,data} = params

-            openticket.log(user.displayName+" added "+data.displayName+" to a ticket!","info",[
+            opendiscord.log(user.displayName+" added "+data.displayName+" to a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -81,8 +81,8 @@ export const registerActions = async () => {
            ])
        })
    ])
-    openticket.actions.get("openticket:add-ticket-user").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:add-ticket-user").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,86 +1,88 @@
 ///////////////////////////////////////
 //TICKET CLAIMING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:claim-ticket"))
-    openticket.actions.get("openticket:claim-ticket").workers.add([
-        new api.ODWorker("openticket:claim-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:claim-ticket"))
+    opendiscord.actions.get("opendiscord:claim-ticket").workers.add([
+        new api.ODWorker("opendiscord:claim-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to claim ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketClaim").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketClaim").emit([ticket,user,channel,reason])
            
            //update ticket
-            ticket.get("openticket:claimed").value = true
-            ticket.get("openticket:claimed-by").value = user.id
-            ticket.get("openticket:claimed-on").value = new Date().getTime()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:claimed").value = true
+            ticket.get("opendiscord:claimed-by").value = user.id
+            ticket.get("opendiscord:claimed-on").value = new Date().getTime()
+            ticket.get("opendiscord:busy").value = true

            //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-claimed",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-claimed",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-claimed",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-claimed",user.id,1,"increase")

            //update category
-            const rawClaimCategory = ticket.option.get("openticket:channel-categories-claimed").value.find((c) => c.user == user.id)
-            const claimCategory = (rawClaimCategory) ? rawClaimCategory.category : null
-            if (claimCategory){
-                try {
-                    channel.setParent(claimCategory,{lockPermissions:false})
-                    ticket.get("openticket:category-mode").value = "claimed"
-                    ticket.get("openticket:category").value = claimCategory
-                }catch(e){
-                    openticket.log("Unable to move ticket to 'claimed category'!","error",[
-                        {key:"channel",value:"#"+channel.name},
-                        {key:"channelid",value:channel.id,hidden:true},
-                        {key:"categoryid",value:claimCategory}
-                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
+                const rawClaimCategory = ticket.option.get("opendiscord:channel-categories-claimed").value.find((c) => c.user == user.id)
+                const claimCategory = (rawClaimCategory) ? rawClaimCategory.category : null
+                if (claimCategory){
+                    try {
+                        channel.setParent(claimCategory,{lockPermissions:false})
+                        ticket.get("opendiscord:category-mode").value = "claimed"
+                        ticket.get("opendiscord:category").value = claimCategory
+                    }catch(e){
+                        opendiscord.log("Unable to move ticket to 'claimed category'!","error",[
+                            {key:"channel",value:"#"+channel.name},
+                            {key:"channelid",value:channel.id,hidden:true},
+                            {key:"categoryid",value:claimCategory}
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    }
                }
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket claiming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket claiming!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:claim-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketClaimed").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build(source,{guild,channel,user,ticket,reason})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketClaimed").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.claiming.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.claiming.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.claiming.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" claimed a ticket!","info",[
+            opendiscord.log(user.displayName+" claimed a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -90,188 +92,188 @@ export const registerActions = async () => {
            ])
        })
    ])
-    openticket.actions.get("openticket:claim-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:claim-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }

 export const registerVerifyBars = async () => {
    //CLAIM TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:claim-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:claim-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:claim-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:claim-ticket-ticket-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.claim

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already claimed
-            if (ticket.get("openticket:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
+            if (ticket.get("opendiscord:claimed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start claiming ticket
            if (params.data == "reason"){
                //claim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:claim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:claim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
            }else{
                //claim without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:claim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:claim-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:claim-ticket-ticket-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
        })
    ])

    //CLAIM TICKET UNCLAIM MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:claim-ticket-unclaim-message",openticket.builders.messages.getSafe("openticket:verifybar-unclaim-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:claim-ticket-unclaim-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:claim-ticket-unclaim-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-unclaim-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:claim-ticket-unclaim-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.claim

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already claimed
-            if (ticket.get("openticket:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
+            if (ticket.get("opendiscord:claimed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start claiming ticket
            if (params.data == "reason"){
                //claim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:claim-ticket-reason").build("unclaim-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:claim-ticket-reason").build("unclaim-message",{guild,channel,user,ticket}))
            }else{
                //claim without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run("unclaim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:claim-message").build("unclaim-message",{guild,channel,user,ticket,reason:null}))
+                await opendiscord.actions.get("opendiscord:claim-ticket").run("unclaim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build("unclaim-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:claim-ticket-unclaim-message").failure.add([
-        new api.ODWorker("openticket:back-to-unclaim-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:claim-ticket-unclaim-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-unclaim-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:unclaim-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])
 }
@@ -1,40 +1,60 @@
 ///////////////////////////////////////
 //CLEAR TICKETS SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:clear-tickets"))
-    openticket.actions.get("openticket:clear-tickets").workers.add([
-        new api.ODWorker("openticket:clear-tickets",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:clear-tickets"))
+    opendiscord.actions.get("opendiscord:clear-tickets").workers.add([
+        new api.ODWorker("opendiscord:clear-tickets",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,filter,list} = params
            
-            await openticket.events.get("onTicketsClear").emit([list,user,channel,filter])
+            await opendiscord.events.get("onTicketsClear").emit([list,user,channel,filter])
            const nameList: string[] = []
-            for (const ticket of list){
-                const ticketChannel = await openticket.tickets.getTicketChannel(ticket)
-                if (!ticketChannel) return
-                nameList.push("#"+ticketChannel.name)
-                await openticket.actions.get("openticket:delete-ticket").run("clear",{guild,channel:ticketChannel,user,ticket,reason:"Cleared Ticket",sendMessage:true,withoutTranscript:false})
+
+            //split tickets into smaller groups of 10 (to decrease ratelimit chances for HTML Transcripts & discord API)
+            const subGroupList: api.ODTicket[][] = []
+            let tempSubGroup: api.ODTicket[] = []
+            list.forEach((ticket,index) => {
+                tempSubGroup.push(ticket)
+                if (tempSubGroup.length >= 10){
+                    subGroupList.push(tempSubGroup)
+                    tempSubGroup = []
+                }
+            })
+            if (tempSubGroup.length > 0) subGroupList.push(tempSubGroup)
+
+            let groupIndex = 0
+            for (const ticketGroup of subGroupList){
+                for (const ticket of ticketGroup){
+                    const ticketChannel = await opendiscord.tickets.getTicketChannel(ticket)
+                    if (!ticketChannel) return
+                    nameList.push("#"+ticketChannel.name)
+                    await opendiscord.actions.get("opendiscord:delete-ticket").run("clear",{guild,channel:ticketChannel,user,ticket,reason:"Cleared Ticket",sendMessage:true,withoutTranscript:false})
+                    await utilities.timer(2000) //wait 2sec between each deletion
+                }
+                if (groupIndex < subGroupList.length-1) await utilities.timer(45*1000) //wait 45sec between each group deletion (10 tickets)
+                groupIndex++
            }
+            
            instance.list = nameList
-            await openticket.events.get("afterTicketsCleared").emit([list,user,channel,filter])
+            await opendiscord.events.get("afterTicketsCleared").emit([list,user,channel,filter])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,filter,list} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.deleting.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:clear-logs").build(source,{guild,channel,user,filter,list:instance.list ?? []}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:clear-logs").build(source,{guild,channel,user,filter,list:instance.list ?? []}))
            }
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,user,filter,list} = params
-            openticket.log(user.displayName+" cleared "+list.length+" tickets!","info",[
+            opendiscord.log(user.displayName+" cleared "+list.length+" tickets!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"method",value:source},
@@ -1,46 +1,48 @@
 ///////////////////////////////////////
 //TICKET CLOSING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:close-ticket"))
-    openticket.actions.get("openticket:close-ticket").workers.add([
-        new api.ODWorker("openticket:close-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:close-ticket"))
+    opendiscord.actions.get("opendiscord:close-ticket").workers.add([
+        new api.ODWorker("opendiscord:close-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to close ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketClose").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketClose").emit([ticket,user,channel,reason])
            
            //update ticket
-            ticket.get("openticket:closed").value = true
-            if (source == "autoclose") ticket.get("openticket:autoclosed").value = true
-            ticket.get("openticket:open").value = false
-            ticket.get("openticket:closed-by").value = user.id
-            ticket.get("openticket:closed-on").value = new Date().getTime()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:closed").value = true
+            if (source == "autoclose") ticket.get("opendiscord:autoclosed").value = true
+            ticket.get("opendiscord:open").value = false
+            ticket.get("opendiscord:closed-by").value = user.id
+            ticket.get("opendiscord:closed-on").value = new Date().getTime()
+            ticket.get("opendiscord:busy").value = true

            //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-closed",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-closed",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-closed",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-closed",user.id,1,"increase")

            //update category
-            const closeCategory = ticket.option.get("openticket:channel-category-closed").value
-            if (closeCategory !== ""){
-                try {
-                    channel.setParent(closeCategory,{lockPermissions:false})
-                    ticket.get("openticket:category-mode").value = "closed"
-                    ticket.get("openticket:category").value = closeCategory
-                }catch(e){
-                    openticket.log("Unable to move ticket to 'closed category'!","error",[
-                        {key:"channel",value:"#"+channel.name},
-                        {key:"channelid",value:channel.id,hidden:true},
-                        {key:"categoryid",value:closeCategory}
-                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
+                const closeCategory = ticket.option.get("opendiscord:channel-category-closed").value
+                if (closeCategory !== ""){
+                    try {
+                        channel.setParent(closeCategory,{lockPermissions:false})
+                        ticket.get("opendiscord:category-mode").value = "closed"
+                        ticket.get("opendiscord:category").value = closeCategory
+                    }catch(e){
+                        opendiscord.log("Unable to move ticket to 'closed category'!","error",[
+                            {key:"channel",value:"#"+channel.name},
+                            {key:"channelid",value:channel.id,hidden:true},
+                            {key:"categoryid",value:closeCategory}
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    }
                }
            }

@@ -51,9 +53,9 @@ export const registerActions = async () => {
                allow:[],
                deny:["ViewChannel","SendMessages","ReadMessageHistory"]
            }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
-            const optionAdmins = ticket.option.get("openticket:admins").value
-            const readonlyAdmins = ticket.option.get("openticket:admins-readonly").value
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
+            const optionAdmins = ticket.option.get("opendiscord:admins").value
+            const readonlyAdmins = ticket.option.get("opendiscord:admins-readonly").value

            globalAdmins.forEach((admin) => {
                permissions.push({
@@ -82,7 +84,7 @@ export const registerActions = async () => {
                    deny:["SendMessages","AddReactions","AttachFiles","SendPolls"]
                })
            })
-            ticket.get("openticket:participants").value.forEach((participant) => {
+            ticket.get("opendiscord:participants").value.forEach((participant) => {
                //all participants that aren't roles/admins => readonly (OR non-viewable when enabled)
                if (participant.type == "user"){
                    if (generalConfig.data.system.removeParticipantsOnClose) permissions.push({
@@ -102,43 +104,43 @@ export const registerActions = async () => {
            channel.permissionOverwrites.set(permissions)

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket closing!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket closing!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:close-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketClosed").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:close-message").build(source,{guild,channel,user,ticket,reason})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketClosed").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.closing.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.closing.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.closing.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" closed a ticket!","info",[
+            opendiscord.log(user.displayName+" closed a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -148,188 +150,188 @@ export const registerActions = async () => {
            ])
        })
    ])
-    openticket.actions.get("openticket:close-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:close-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }

 export const registerVerifyBars = async () => {
    //CLOSE TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:close-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:close-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:close-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:close-ticket-ticket-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.close

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already closed
-            if (ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+            if (ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start closing ticket
            if (params.data == "reason"){
                //close with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:close-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:close-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
            }else{
                //close without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:close-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:close-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:close-ticket-ticket-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
        })
    ])

    //CLOSE TICKET REOPEN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:close-ticket-reopen-message",openticket.builders.messages.getSafe("openticket:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:close-ticket-reopen-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:close-ticket-reopen-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:close-ticket-reopen-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.close

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already closed
-            if (ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+            if (ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start closing ticket
            if (params.data == "reason"){
                //close with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:close-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:close-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
            }else{
                //close without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
+                await opendiscord.actions.get("opendiscord:close-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:close-ticket-reopen-message").failure.add([
-        new api.ODWorker("openticket:back-to-reopen-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:close-ticket-reopen-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-reopen-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])
 }
@@ -1,26 +1,26 @@
 ///////////////////////////////////////
 //TICKET CREATION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:create-ticket"))
-    openticket.actions.get("openticket:create-ticket").workers.add([
-        new api.ODWorker("openticket:create-ticket",3,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:create-ticket"))
+    opendiscord.actions.get("opendiscord:create-ticket").workers.add([
+        new api.ODWorker("opendiscord:create-ticket",3,async (instance,params,source,cancel) => {
            const {guild,user,answers,option} = params

-            await openticket.events.get("onTicketCreate").emit([user])
-            await openticket.events.get("onTicketChannelCreation").emit([option,user])
+            await opendiscord.events.get("onTicketCreate").emit([user])
+            await opendiscord.events.get("onTicketChannelCreation").emit([option,user])

            //get channel properties
-            const channelPrefix = option.get("openticket:channel-prefix").value
-            const channelCategory = option.get("openticket:channel-category").value
-            const channelBackupCategory = option.get("openticket:channel-category-backup").value
-            const channelDescription = option.get("openticket:channel-description").value
-            const channelSuffix = openticket.options.suffix.getSuffixFromOption(option,user)
+            const channelPrefix = option.get("opendiscord:channel-prefix").value
+            const channelCategory = option.get("opendiscord:channel-category").value
+            const channelBackupCategory = option.get("opendiscord:channel-category-backup").value
+            const channelDescription = option.get("opendiscord:channel-description").value
+            const channelSuffix = opendiscord.options.suffix.getSuffixFromOption(option,user)
            const channelName = channelPrefix+channelSuffix

            //handle category
@@ -28,10 +28,10 @@ export const registerActions = async () => {
            let categoryMode: "backup"|"normal"|null = null
            if (channelCategory != ""){
                //category enabled
-                const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
+                const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
                if (!normalCategory){
                    //default category was not found
-                    openticket.log("Ticket Creation Error: Unable to find category! #1","error",[
+                    opendiscord.log("Ticket Creation Error: Unable to find category! #1","error",[
                        {key:"categoryid",value:channelCategory},
                        {key:"backup",value:"false"}
                    ])
@@ -39,10 +39,10 @@ export const registerActions = async () => {
                    //default category was found
                    if (normalCategory.children.cache.size >= 50 && channelBackupCategory != ""){
                        //use backup category
-                        const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                        const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
                        if (!backupCategory){
                            //default category was not found
-                            openticket.log("Ticket Creation Error: Unable to find category! #2","error",[
+                            opendiscord.log("Ticket Creation Error: Unable to find category! #2","error",[
                                {key:"categoryid",value:channelBackupCategory},
                                {key:"backup",value:"true"}
                            ])
@@ -65,9 +65,9 @@ export const registerActions = async () => {
                allow:[],
                deny:["ViewChannel","SendMessages","ReadMessageHistory"]
            }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
-            const optionAdmins = option.get("openticket:admins").value
-            const readonlyAdmins = option.get("openticket:admins-readonly").value
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
+            const optionAdmins = option.get("opendiscord:admins").value
+            const readonlyAdmins = option.get("opendiscord:admins-readonly").value

            globalAdmins.forEach((admin) => {
                permissions.push({
@@ -114,7 +114,7 @@ export const registerActions = async () => {
                permissionOverwrites:permissions
            })

-            await openticket.events.get("afterTicketChannelCreated").emit([option,channel,user])
+            await opendiscord.events.get("afterTicketChannelCreated").emit([option,channel,user])

            //create participants
            const participants: {type:"role"|"user",id:string}[] = []
@@ -127,96 +127,96 @@ export const registerActions = async () => {

            //create ticket
            const ticket = new api.ODTicket(channel.id,option,[
-                new api.ODTicketData("openticket:busy",false),
-                new api.ODTicketData("openticket:ticket-message",null),
-                new api.ODTicketData("openticket:participants",participants),
-                new api.ODTicketData("openticket:channel-suffix",channelSuffix),
+                new api.ODTicketData("opendiscord:busy",false),
+                new api.ODTicketData("opendiscord:ticket-message",null),
+                new api.ODTicketData("opendiscord:participants",participants),
+                new api.ODTicketData("opendiscord:channel-suffix",channelSuffix),
                
-                new api.ODTicketData("openticket:open",true),
-                new api.ODTicketData("openticket:opened-by",user.id),
-                new api.ODTicketData("openticket:opened-on",new Date().getTime()),
-                new api.ODTicketData("openticket:closed",false),
-                new api.ODTicketData("openticket:closed-by",null),
-                new api.ODTicketData("openticket:closed-on",null),
-                new api.ODTicketData("openticket:claimed",false),
-                new api.ODTicketData("openticket:claimed-by",null),
-                new api.ODTicketData("openticket:claimed-on",null),
-                new api.ODTicketData("openticket:pinned",false),
-                new api.ODTicketData("openticket:pinned-by",null),
-                new api.ODTicketData("openticket:pinned-on",null),
-                new api.ODTicketData("openticket:for-deletion",false),
+                new api.ODTicketData("opendiscord:open",true),
+                new api.ODTicketData("opendiscord:opened-by",user.id),
+                new api.ODTicketData("opendiscord:opened-on",new Date().getTime()),
+                new api.ODTicketData("opendiscord:closed",false),
+                new api.ODTicketData("opendiscord:closed-by",null),
+                new api.ODTicketData("opendiscord:closed-on",null),
+                new api.ODTicketData("opendiscord:claimed",false),
+                new api.ODTicketData("opendiscord:claimed-by",null),
+                new api.ODTicketData("opendiscord:claimed-on",null),
+                new api.ODTicketData("opendiscord:pinned",false),
+                new api.ODTicketData("opendiscord:pinned-by",null),
+                new api.ODTicketData("opendiscord:pinned-on",null),
+                new api.ODTicketData("opendiscord:for-deletion",false),

-                new api.ODTicketData("openticket:category",category),
-                new api.ODTicketData("openticket:category-mode",categoryMode),
+                new api.ODTicketData("opendiscord:category",category),
+                new api.ODTicketData("opendiscord:category-mode",categoryMode),

-                new api.ODTicketData("openticket:autoclose-enabled",option.get("openticket:autoclose-enable-hours").value),
-                new api.ODTicketData("openticket:autoclose-hours",(option.get("openticket:autoclose-enable-hours").value ? option.get("openticket:autoclose-hours").value : 0)),
-                new api.ODTicketData("openticket:autoclosed",false),
-                new api.ODTicketData("openticket:autodelete-enabled",option.get("openticket:autodelete-enable-days").value),
-                new api.ODTicketData("openticket:autodelete-days",(option.get("openticket:autodelete-enable-days").value ? option.get("openticket:autodelete-days").value : 0)),
+                new api.ODTicketData("opendiscord:autoclose-enabled",option.get("opendiscord:autoclose-enable-hours").value),
+                new api.ODTicketData("opendiscord:autoclose-hours",(option.get("opendiscord:autoclose-enable-hours").value ? option.get("opendiscord:autoclose-hours").value : 0)),
+                new api.ODTicketData("opendiscord:autoclosed",false),
+                new api.ODTicketData("opendiscord:autodelete-enabled",option.get("opendiscord:autodelete-enable-days").value),
+                new api.ODTicketData("opendiscord:autodelete-days",(option.get("opendiscord:autodelete-enable-days").value ? option.get("opendiscord:autodelete-days").value : 0)),

-                new api.ODTicketData("openticket:answers",answers)
+                new api.ODTicketData("opendiscord:answers",answers)
            ])

            //manage stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-created",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-created",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-created",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-created",user.id,1,"increase")

            //manage bot permissions
-            await openticket.events.get("onTicketPermissionsCreated").emit([option,openticket.permissions,channel,user])
+            await opendiscord.events.get("onTicketPermissionsCreated").emit([option,opendiscord.permissions,channel,user])
            await (await import("../data/framework/permissionLoader.js")).addTicketPermissions(ticket)
-            await openticket.events.get("afterTicketPermissionsCreated").emit([option,openticket.permissions,channel,user])
+            await opendiscord.events.get("afterTicketPermissionsCreated").emit([option,opendiscord.permissions,channel,user])

            //export channel & ticket
            instance.channel = channel
            instance.ticket = ticket
-            openticket.tickets.add(ticket)
+            opendiscord.tickets.add(ticket)
        }),
-        new api.ODWorker("openticket:send-ticket-message",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:send-ticket-message",2,async (instance,params,source,cancel) => {
            const {guild,user,answers,option} = params
            const {ticket,channel} = instance

-            if (!ticket || !channel) return openticket.log("Ticket Creation Error: Unable to send ticket message. Previous worker failed!","error")
+            if (!ticket || !channel) return opendiscord.log("Ticket Creation Error: Unable to send ticket message. Previous worker failed!","error")
            
-            await openticket.events.get("onTicketMainMessageCreated").emit([ticket,channel,user])
+            await opendiscord.events.get("onTicketMainMessageCreated").emit([ticket,channel,user])
            //check if ticket message is enabled
-            if (!option.get("openticket:ticket-message-enabled").value) return
+            if (!option.get("opendiscord:ticket-message-enabled").value) return
            try {
-                const msg = await channel.send((await openticket.builders.messages.getSafe("openticket:ticket-message").build(source,{guild,channel,user,ticket})).message)
+                const msg = await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build(source,{guild,channel,user,ticket})).message)
                
-                ticket.get("openticket:ticket-message").value = msg.id
+                ticket.get("opendiscord:ticket-message").value = msg.id
                
                //manage stats
-                await openticket.stats.get("openticket:ticket").setStat("openticket:messages-sent",ticket.id.value,1,"increase")
+                await opendiscord.stats.get("opendiscord:ticket").setStat("opendiscord:messages-sent",ticket.id.value,1,"increase")
                
-                await openticket.events.get("afterTicketMainMessageCreated").emit([ticket,msg,channel,user])
+                await opendiscord.events.get("afterTicketMainMessageCreated").emit([ticket,msg,channel,user])
        }catch(err){
                process.emit("uncaughtException",err)
                //something went wrong while sending the ticket message
-                channel.send((await openticket.builders.messages.getSafe("openticket:error").build("other",{guild,channel,user,error:"Ticket Message: Creation Error!\n=> Ticket Is Still Created Succesfully",layout:"advanced"})).message)
+                channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error").build("other",{guild,channel,user,error:"Ticket Message: Creation Error!\n=> Ticket Is Still Created Succesfully",layout:"advanced"})).message)
            }
-            await openticket.events.get("afterTicketCreated").emit([ticket,user,channel])
+            await opendiscord.events.get("afterTicketCreated").emit([ticket,user,channel])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,user,answers,option} = params
            const {ticket,channel} = instance

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.creation.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-created-logs").build(source,{guild,channel,user,ticket}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-created-logs").build(source,{guild,channel,user,ticket}))
            }

            //to dm
-            if (generalConfig.data.system.messages.creation.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-created-dm").build(source,{guild,channel,user,ticket}))
+            if (generalConfig.data.system.messages.creation.dm) await opendiscord.client.sendUserDm(user,await opendiscord.builders.messages.getSafe("opendiscord:ticket-created-dm").build(source,{guild,channel,user,ticket}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,user,answers,option} = params
            const {ticket,channel} = instance

-            if (!ticket || !channel) return openticket.log("Ticket Creation Error: Unable to create logs. Previous worker failed!","error")
+            if (!ticket || !channel) return opendiscord.log("Ticket Creation Error: Unable to create logs. Previous worker failed!","error")

-            openticket.log(user.displayName+" created a ticket!","info",[
+            opendiscord.log(user.displayName+" created a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -1,17 +1,17 @@
 ///////////////////////////////////////
 //TICKET CREATION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:create-ticket-permissions"))
-    openticket.actions.get("openticket:create-ticket-permissions").workers.add([
-        new api.ODWorker("openticket:check-blacklist",4,(instance,params,source,cancel) => {
-            if (!params.option.get("openticket:allow-blacklisted-users").value && openticket.blacklist.exists(params.user.id)){
+    opendiscord.actions.add(new api.ODAction("opendiscord:create-ticket-permissions"))
+    opendiscord.actions.get("opendiscord:create-ticket-permissions").workers.add([
+        new api.ODWorker("opendiscord:check-blacklist",4,(instance,params,source,cancel) => {
+            if (!params.option.get("opendiscord:allow-blacklisted-users").value && opendiscord.blacklist.exists(params.user.id)){
                instance.valid = false
                instance.reason = "blacklist"
-                openticket.log(params.user.displayName+" tried to create a ticket but is blacklisted!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket but is blacklisted!","info",[
                    {key:"user",value:params.user.username},
                    {key:"userid",value:params.user.id,hidden:true},
                    {key:"option",value:params.option.id.value}
@@ -19,15 +19,15 @@ export const registerActions = async () => {
                return cancel()
            }
        }),
-        new api.ODWorker("openticket:check-cooldown",3,(instance,params,source,cancel) => {
-            const cooldown = openticket.cooldowns.get("openticket:option-cooldown_"+params.option.id.value)
+        new api.ODWorker("opendiscord:check-cooldown",3,(instance,params,source,cancel) => {
+            const cooldown = opendiscord.cooldowns.get("opendiscord:option-cooldown_"+params.option.id.value)
            if (cooldown && cooldown instanceof api.ODTimeoutCooldown && cooldown.use(params.user.id)){
                instance.valid = false
                instance.reason = "cooldown"
                const remaining = cooldown.remaining(params.user.id) ?? 0
                instance.cooldownUntil = new Date(new Date().getTime() + remaining)

-                openticket.log(params.user.displayName+" tried to create a ticket but is on cooldown!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket but is on cooldown!","info",[
                    {key:"user",value:params.user.username},
                    {key:"userid",value:params.user.id,hidden:true},
                    {key:"option",value:params.option.id.value},
@@ -36,19 +36,19 @@ export const registerActions = async () => {
                return cancel()
            }
        }),
-        new api.ODWorker("openticket:check-global-limits",2,(instance,params,source,cancel) => {
-            const generalConfig = openticket.configs.get("openticket:general")
+        new api.ODWorker("opendiscord:check-global-limits",2,(instance,params,source,cancel) => {
+            const generalConfig = opendiscord.configs.get("opendiscord:general")
            if (!generalConfig.data.system.limits.enabled) return

-            const allTickets = openticket.tickets.getAll()
+            const allTickets = opendiscord.tickets.getAll()
            const globalTicketCount = allTickets.length
-            const userTickets = openticket.tickets.getFiltered((ticket) => ticket.exists("openticket:opened-by") && (ticket.get("openticket:opened-by").value == params.user.id))
+            const userTickets = opendiscord.tickets.getFiltered((ticket) => ticket.exists("opendiscord:opened-by") && (ticket.get("opendiscord:opened-by").value == params.user.id))
            const userTicketCount = userTickets.length

            if (globalTicketCount >= generalConfig.data.system.limits.globalMaximum){
                instance.valid = false
                instance.reason = "global-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket but reached the limit!","info",[
                    {key:"user",value:params.user.username},
                    {key:"userid",value:params.user.id,hidden:true},
                    {key:"option",value:params.option.id.value},
@@ -58,7 +58,7 @@ export const registerActions = async () => {
            }else if (userTicketCount >= generalConfig.data.system.limits.userMaximum){
                instance.valid = false
                instance.reason = "global-user-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
                    {key:"user",value:params.user.username},
                    {key:"userid",value:params.user.id,hidden:true},
                    {key:"option",value:params.option.id.value},
@@ -67,28 +67,28 @@ export const registerActions = async () => {
                return cancel()
            }
        }),
-        new api.ODWorker("openticket:check-option-limits",1,(instance,params,source,cancel) => {
-            if (!params.option.exists("openticket:limits-enabled") || !params.option.get("openticket:limits-enabled").value) return
+        new api.ODWorker("opendiscord:check-option-limits",1,(instance,params,source,cancel) => {
+            if (!params.option.exists("opendiscord:limits-enabled") || !params.option.get("opendiscord:limits-enabled").value) return

-            const allTickets = openticket.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value)
+            const allTickets = opendiscord.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value)
            const globalTicketCount = allTickets.length
-            const userTickets = openticket.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value && ticket.exists("openticket:opened-by") && (ticket.get("openticket:opened-by").value == params.user.id))
+            const userTickets = opendiscord.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value && ticket.exists("opendiscord:opened-by") && (ticket.get("opendiscord:opened-by").value == params.user.id))
            const userTicketCount = userTickets.length

-            if (globalTicketCount >= params.option.get("openticket:limits-maximum-global").value){
+            if (globalTicketCount >= params.option.get("opendiscord:limits-maximum-global").value){
                instance.valid = false
                instance.reason = "option-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
                    {key:"user",value:params.user.username},
                    {key:"userid",value:params.user.id,hidden:true},
                    {key:"option",value:params.option.id.value},
                    {key:"limit",value:"option"}
                ])
                return cancel()
-            }else if (userTicketCount >= params.option.get("openticket:limits-maximum-user").value){
+            }else if (userTicketCount >= params.option.get("opendiscord:limits-maximum-user").value){
                instance.valid = false
                instance.reason = "option-user-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
                    {key:"user",value:params.user.username},
                    {key:"userid",value:params.user.id,hidden:true},
                    {key:"option",value:params.option.id.value},
@@ -97,7 +97,7 @@ export const registerActions = async () => {
                return cancel()
            }
        }),
-        new api.ODWorker("openticket:valid",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:valid",0,(instance,params,source,cancel) => {
            instance.valid = true
            instance.reason = null
            cancel()
@@ -1,23 +1,23 @@
 ///////////////////////////////////////
 //TRANSCRIPT CREATION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const transcriptConfig = openticket.configs.get("openticket:transcripts")
+const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:create-transcript"))
-    openticket.actions.get("openticket:create-transcript").workers.add([
-        new api.ODWorker("openticket:select-compiler",4,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:create-transcript"))
+    opendiscord.actions.get("opendiscord:create-transcript").workers.add([
+        new api.ODWorker("opendiscord:select-compiler",4,async (instance,params,source,cancel) => {
            const {channel,user,ticket} = params
            if (channel.type != discord.ChannelType.GuildText) return cancel()
            if (!transcriptConfig.data.general.enabled) return cancel()
            
-            await openticket.events.get("onTranscriptCreate").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("onTranscriptCreate").emit([opendiscord.transcripts,ticket,channel,user])
            
            instance.errorReason = null
-            const participants = await openticket.tickets.getAllTicketParticipants(params.ticket)
+            const participants = await opendiscord.tickets.getAllTicketParticipants(params.ticket)
            if (!participants){
                instance.pendingMessage = null
                instance.errorReason = "Unable to fetch ticket channel participants!"
@@ -26,22 +26,24 @@ export const registerActions = async () => {
            instance.participants = participants

            //select transcript compiler
-            if (transcriptConfig.data.general.mode == "text") instance.compiler = openticket.transcripts.get("openticket:text-compiler")
-            else if (transcriptConfig.data.general.mode == "html") instance.compiler = openticket.transcripts.get("openticket:html-compiler")
+            if (transcriptConfig.data.general.mode == "text") instance.compiler = opendiscord.transcripts.get("opendiscord:text-compiler")
+            else if (transcriptConfig.data.general.mode == "html") instance.compiler = opendiscord.transcripts.get("opendiscord:html-compiler")
        }),
-        new api.ODWorker("openticket:init-transcript",3,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:init-transcript",3,async (instance,params,source,cancel) => {
            const {channel,user,ticket} = params
            if (channel.type != discord.ChannelType.GuildText) return cancel()
            if (!transcriptConfig.data.general.enabled) return cancel()
            
            //run transcript compiler init()
-            await openticket.events.get("onTranscriptInit").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("onTranscriptInit").emit([opendiscord.transcripts,ticket,channel,user])
            if (instance.compiler.init){
                try{
+                    instance.initData = null
                    const result = await instance.compiler.init(ticket,channel,user)
+                    instance.initData = result.initData
                    if (result.success && result.pendingMessage && transcriptConfig.data.general.enableChannel){
                        //send init message to channel
-                        const post = openticket.posts.get("openticket:transcripts")
+                        const post = opendiscord.posts.get("opendiscord:transcripts")
                        if (post){
                            instance.pendingMessage = await post.send(result.pendingMessage)
                        }
@@ -49,7 +51,9 @@ export const registerActions = async () => {
                        instance.pendingMessage = null
                        instance.errorReason = result.errorReason
                        throw new api.ODSystemError("ODAction(ot:create-transcript) => Known Init Error => "+result.errorReason)
-                    }else instance.pendingMessage = null
+                    }else{
+                        instance.pendingMessage = null
+                    }
                }catch(err){
                    instance.success = false
                    cancel()
@@ -57,9 +61,9 @@ export const registerActions = async () => {
                    throw new api.ODSystemError("ODAction(ot:create-transcript) => Failed transcript compiler init()! (see error above)")
                }
            }
-            await openticket.events.get("afterTranscriptInitiated").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("afterTranscriptInitiated").emit([opendiscord.transcripts,ticket,channel,user])
        }),
-        new api.ODWorker("openticket:compile-transcript",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:compile-transcript",2,async (instance,params,source,cancel) => {
            const {channel,user,ticket} = params
            if (channel.type != discord.ChannelType.GuildText) return cancel()
            if (!instance.compiler){
@@ -69,10 +73,10 @@ export const registerActions = async () => {
            }

            //run transcript compiler compile()
-            await openticket.events.get("onTranscriptCompile").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("onTranscriptCompile").emit([opendiscord.transcripts,ticket,channel,user])
            if (instance.compiler.compile){
                try{
-                    const result = await instance.compiler.compile(ticket,channel,user)
+                    const result = await instance.compiler.compile(ticket,channel,user,instance.initData)
                    if (!result.success){
                        instance.errorReason = result.errorReason
                        throw new api.ODSystemError("ODAction(ot:create-transcript) => Known Compiler Error => "+result.errorReason)
@@ -87,9 +91,9 @@ export const registerActions = async () => {
                    throw new api.ODSystemError("ODAction(ot:create-transcript) => Failed transcript compiler compile()! (see error above)")
                }
            }
-            await openticket.events.get("afterTranscriptCompiled").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("afterTranscriptCompiled").emit([opendiscord.transcripts,ticket,channel,user])
        }),
-        new api.ODWorker("openticket:ready-transcript",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:ready-transcript",1,async (instance,params,source,cancel) => {
            if (!instance.result){
                instance.success = false
                cancel()
@@ -98,7 +102,7 @@ export const registerActions = async () => {

            //run transcript compiler ready()
            utilities.runAsync(async () => {
-                await openticket.events.get("onTranscriptReady").emit([openticket.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
+                await opendiscord.events.get("onTranscriptReady").emit([opendiscord.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
                if (instance.compiler.ready){
                    try{
                        const {channelMessage,creatorDmMessage,participantDmMessage,activeAdminDmMessage,everyAdminDmMessage} = await instance.compiler.ready(instance.result)
@@ -110,7 +114,7 @@ export const registerActions = async () => {
                                instance.pendingMessage.message.edit(channelMessage.message)
                            }else{
                                //send ready message to channel
-                                const post = openticket.posts.get("openticket:transcripts")
+                                const post = opendiscord.posts.get("opendiscord:transcripts")
                                if (post) await post.send(channelMessage)
                            }
                        }
@@ -120,16 +124,16 @@ export const registerActions = async () => {
                            for (const p of instance.participants){
                                if (p.role == "creator" && transcriptConfig.data.general.enableCreatorDM && creatorDmMessage){
                                    //send creator dm message
-                                    await openticket.client.sendUserDm(p.user,creatorDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,creatorDmMessage)
                                }else if (p.role == "participant" && transcriptConfig.data.general.enableParticipantDM && participantDmMessage){
                                    //send participant dm message
-                                    await openticket.client.sendUserDm(p.user,participantDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,participantDmMessage)
                                }else if (p.role == "admin" && transcriptConfig.data.general.enableActiveAdminDM && instance.result.success && instance.result.messages && instance.result.messages.some((msg) => msg.author.id == p.user.id) && activeAdminDmMessage){
                                    //send active admin dm message
-                                    await openticket.client.sendUserDm(p.user,activeAdminDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,activeAdminDmMessage)
                                }else if (p.role == "admin" && transcriptConfig.data.general.enableEveryAdminDM && everyAdminDmMessage){
                                    //send every admin dm message
-                                    await openticket.client.sendUserDm(p.user,everyAdminDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,everyAdminDmMessage)
                                }
                            }
                        }
@@ -141,17 +145,17 @@ export const registerActions = async () => {
                        throw new api.ODSystemError("ODAction(ot:create-transcript) => Failed transcript compiler ready()! (see error above)")
                    }
                }
-                await openticket.events.get("afterTranscriptReady").emit([openticket.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
+                await opendiscord.events.get("afterTranscriptReady").emit([opendiscord.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
            })

            //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:transcripts-created",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:transcripts-created",params.user.id,1,"increase")
-            await openticket.events.get("afterTranscriptCreated").emit([openticket.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:transcripts-created",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:transcripts-created",params.user.id,1,"increase")
+            await opendiscord.events.get("afterTranscriptCreated").emit([opendiscord.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {user,channel,ticket} = params
-            openticket.log(user.displayName+" created a transcript!","info",[
+            opendiscord.log(user.displayName+" created a transcript!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -1,55 +1,55 @@
 ///////////////////////////////////////
 //TICKET DELETION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:delete-ticket"))
-    openticket.actions.get("openticket:delete-ticket").workers.add([
-        new api.ODWorker("openticket:delete-ticket",3,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:delete-ticket"))
+    opendiscord.actions.get("opendiscord:delete-ticket").workers.add([
+        new api.ODWorker("opendiscord:delete-ticket",3,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to delete ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketDelete").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketDelete").emit([ticket,user,channel,reason])

            //update ticket
-            ticket.get("openticket:for-deletion").value = true
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:for-deletion").value = true
+            ticket.get("opendiscord:busy").value = true

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket deletion!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket deletion!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:delete-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build(source,{guild,channel,user,ticket,reason})).message)
        
            //create transcript
            if (!params.withoutTranscript){
-                const transcriptRes = await openticket.actions.get("openticket:create-transcript").run(source,{guild,channel,user,ticket})
+                const transcriptRes = await opendiscord.actions.get("opendiscord:create-transcript").run(source,{guild,channel,user,ticket})
                //transcript failure
                if (typeof transcriptRes.success == "boolean" && !transcriptRes.success && transcriptRes.compiler){
                    const {compiler} = transcriptRes
-                    await channel.send((await openticket.builders.messages.getSafe("openticket:transcript-error").build(source,{guild,channel,user,ticket,compiler,reason:transcriptRes.errorReason ?? null})).message)
-                        .catch((reason) => openticket.log("Unable to send transcript failure to ticket channel!","error",[{key:"id",value:channel.id}]))
+                    await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:transcript-error").build(source,{guild,channel,user,ticket,compiler,reason:transcriptRes.errorReason ?? null})).message)
+                        .catch((reason) => opendiscord.log("Unable to send transcript failure to ticket channel!","error",[{key:"id",value:channel.id}]))
                
                    //undo deletion
-                    ticket.get("openticket:for-deletion").value = false
-                    ticket.get("openticket:busy").value = false
-                    openticket.log("Canceled ticket deletion because of transcript system malfunction!","warning",[
+                    ticket.get("opendiscord:for-deletion").value = false
+                    ticket.get("opendiscord:busy").value = false
+                    opendiscord.log("Canceled ticket deletion because of transcript system malfunction!","warning",[
                        {key:"compiler",value:compiler.id.value},
                        {key:"reason",value:transcriptRes.errorReason ?? "/"},
                    ])
@@ -58,45 +58,45 @@ export const registerActions = async () => {
            }

            //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-deleted",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-deleted",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-deleted",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-deleted",user.id,1,"increase")

            //delete ticket from manager
-            openticket.tickets.remove(ticket.id)
+            opendiscord.tickets.remove(ticket.id)

            //delete permissions from manager
            await (await import("../data/framework/permissionLoader.js")).removeTicketPermissions(ticket)
        }),
-        new api.ODWorker("openticket:discord-logs",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",2,async (instance,params,source,cancel) => {
            //logs before channel deletion => channel might still be used in log embeds
            const {guild,channel,user,ticket,reason} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.deleting.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.deleting.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.deleting.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
        }),
-        new api.ODWorker("openticket:delete-channel",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-channel",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            //delete channel & events
-            await openticket.events.get("onTicketChannelDeletion").emit([ticket,channel,user])
-            await channel.delete("Ticket Deleted").catch((reason) => openticket.log("Unable to delete ticket channel!","error",[{key:"id",value:channel.id}]))
-            await openticket.events.get("afterTicketChannelDeleted").emit([ticket,user])
+            await opendiscord.events.get("onTicketChannelDeletion").emit([ticket,channel,user])
+            await channel.delete("Ticket Deleted").catch((reason) => opendiscord.log("Unable to delete ticket channel!","error",[{key:"id",value:channel.id}]))
+            await opendiscord.events.get("afterTicketChannelDeleted").emit([ticket,user])

            //delete permissions from manager
            await (await import("../data/framework/permissionLoader.js")).removeTicketPermissions(ticket)

-            await openticket.events.get("afterTicketDeleted").emit([ticket,user,reason])
+            await opendiscord.events.get("afterTicketDeleted").emit([ticket,user,reason])
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" deleted a ticket!","info",[
+            opendiscord.log(user.displayName+" deleted a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -107,360 +107,360 @@ export const registerActions = async () => {
            ])
        })
    ])
-    openticket.actions.get("openticket:delete-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:delete-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
-        params.ticket.get("openticket:for-deletion").value = false
+        params.ticket.get("opendiscord:busy").value = false
+        params.ticket.get("opendiscord:for-deletion").value = false
    })
 }

 export const registerVerifyBars = async () => {
    //DELETE TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:delete-ticket-ticket-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.delete

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start deleting ticket
            if (params.data == "reason"){
                //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
            }else{
                //delete without reason
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true,withoutTranscript:(params.data == "no-transcript")})
                //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                ticket.get("opendiscord:for-deletion").value = true
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:delete-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:delete-ticket-ticket-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
        })
    ])

    //DELETE TICKET CLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-close-message",openticket.builders.messages.getSafe("openticket:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-close-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-close-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:delete-ticket-close-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.delete

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start deleting ticket
            if (params.data == "reason"){
                //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("close-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("close-message",{guild,channel,user,ticket}))
            }else{
                //delete without reason
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
                //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("close-message",{guild,channel,user,ticket,reason:null}))
+                ticket.get("opendiscord:for-deletion").value = true
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("close-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:delete-ticket-close-message").failure.add([
-        new api.ODWorker("openticket:back-to-close-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:delete-ticket-close-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-close-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])

    //DELETE TICKET REOPEN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-reopen-message",openticket.builders.messages.getSafe("openticket:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-reopen-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-reopen-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:delete-ticket-reopen-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.delete

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start deleting ticket
            if (params.data == "reason"){
                //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
            }else{
                //delete without reason
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
                //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
+                ticket.get("opendiscord:for-deletion").value = true
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:delete-ticket-reopen-message").failure.add([
-        new api.ODWorker("openticket:back-to-reopen-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:delete-ticket-reopen-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-reopen-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])

    //DELETE TICKET AUTOCLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-autoclose-message",openticket.builders.messages.getSafe("openticket:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-autoclose-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-autoclose-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:delete-ticket-autoclose-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.delete

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start deleting ticket
            if (params.data == "reason"){
                //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
            }else{
                //delete without reason
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
                //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
+                ticket.get("opendiscord:for-deletion").value = true
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:delete-ticket-autoclose-message").failure.add([
-        new api.ODWorker("openticket:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:delete-ticket-autoclose-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:autoclose-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-message").build("other",{guild,channel,user,ticket}))
        })
    ])
 }
@@ -1,80 +1,79 @@
 ///////////////////////////////////////
 //TRANSCRIPT ERROR SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerButtonResponders = async () => {
    //TRANSCRIPT ERROR RETRY
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:transcript-error-retry",/^od:transcript-error-retry_([^_]+)/))
-    openticket.responders.buttons.get("openticket:transcript-error-retry").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:transcript-error-retry",/^od:transcript-error-retry_([^_]+)/))
+    opendiscord.responders.buttons.get("opendiscord:transcript-error-retry").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.delete

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "slash" && originalSource != "text" && originalSource != "ticket-message" && originalSource != "reopen-message" && originalSource != "close-message" && originalSource != "other") return
+            const originalSource = instance.interaction.customId.split("_")[1] as api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"]
            
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start deleting ticket (without reason)
            await instance.defer("update",false)
            //don't await DELETE action => else it will update the message after the channel has been deleted
-            openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Retried)",sendMessage:false,withoutTranscript:false})
+            opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Retried)",sendMessage:false,withoutTranscript:false})
            //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-            ticket.get("openticket:for-deletion").value = true
-            await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Retried)"}))
+            ticket.get("opendiscord:for-deletion").value = true
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Retried)"}))
        
        }),
-        new api.ODWorker("openticket:logs",-1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,async (instance,params,source,cancel) => {
            const {user,channel} = instance
            if (channel.isDMBased()) return
-            openticket.log(user.displayName+" retried deleting a ticket with transcript!","info",[
+            opendiscord.log(user.displayName+" retried deleting a ticket with transcript!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -85,74 +84,73 @@ export const registerButtonResponders = async () => {
    ])

    //TRANSCRIPT ERROR CONTINUE
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:transcript-error-continue",/^od:transcript-error-continue_([^_]+)/))
-    openticket.responders.buttons.get("openticket:transcript-error-continue").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:transcript-error-continue",/^od:transcript-error-continue_([^_]+)/))
+    opendiscord.responders.buttons.get("opendiscord:transcript-error-continue").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.delete

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "slash" && originalSource != "text" && originalSource != "ticket-message" && originalSource != "reopen-message" && originalSource != "close-message" && originalSource != "other") return
+            const originalSource = instance.interaction.customId.split("_")[1] as api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"]
            
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start deleting ticket (without reason)
            await instance.defer("update",false)
            //don't await DELETE action => else it will update the message after the channel has been deleted
-            openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Continued)",sendMessage:false,withoutTranscript:true})
+            opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Continued)",sendMessage:false,withoutTranscript:true})
            //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-            ticket.get("openticket:for-deletion").value = true
-            await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Continued)"}))
+            ticket.get("opendiscord:for-deletion").value = true
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Continued)"}))
        
        }),
-        new api.ODWorker("openticket:logs",-1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,async (instance,params,source,cancel) => {
            const {user,channel} = instance
            if (channel.isDMBased()) return
-            openticket.log(user.displayName+" continued deleting a ticket without transcript!","info",[
+            opendiscord.log(user.displayName+" continued deleting a ticket without transcript!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -1,30 +1,30 @@
 ///////////////////////////////////////
 //VERIFYBAR SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"

 export const registerButtonResponders = async () => {
    //VERIFYBAR SUCCESS
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:verifybar-success",/^od:verifybar-success_([^_]+)/))
-    openticket.responders.buttons.get("openticket:verifybar-success").workers.add(
-        new api.ODWorker("openticket:handle-verifybar",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:verifybar-success",/^od:verifybar-success_([^_]+)/))
+    opendiscord.responders.buttons.get("opendiscord:verifybar-success").workers.add(
+        new api.ODWorker("opendiscord:handle-verifybar",0,async (instance,params,source,cancel) => {
            const id = instance.interaction.customId.split("_")[1]
            const customData = instance.interaction.customId.split("_")[2] as string|undefined
            
-            const verifybar = openticket.verifybars.get(id)
+            const verifybar = opendiscord.verifybars.get(id)
            if (!verifybar) return
            if (verifybar.success) await verifybar.success.executeWorkers(instance,"verifybar",{data:customData ?? null,verifybarMessage:instance.message})
        })
    )

    //VERIFYBAR FAILURE
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:verifybar-failure",/^od:verifybar-failure_([^_]+)/))
-    openticket.responders.buttons.get("openticket:verifybar-failure").workers.add(
-        new api.ODWorker("openticket:handle-verifybar",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:verifybar-failure",/^od:verifybar-failure_([^_]+)/))
+    opendiscord.responders.buttons.get("opendiscord:verifybar-failure").workers.add(
+        new api.ODWorker("opendiscord:handle-verifybar",0,async (instance,params,source,cancel) => {
            const id = instance.interaction.customId.split("_")[1]
            const customData = instance.interaction.customId.split("_")[2] as string|undefined
            
-            const verifybar = openticket.verifybars.get(id)
+            const verifybar = opendiscord.verifybars.get(id)
            if (!verifybar) return
            if (verifybar.failure) await verifybar.failure.executeWorkers(instance,"verifybar",{data:customData ?? null,verifybarMessage:instance.message})
        })
@@ -1,34 +1,34 @@
 ///////////////////////////////////////
 //TICKET MOVING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:move-ticket"))
-    openticket.actions.get("openticket:move-ticket").workers.add([
-        new api.ODWorker("openticket:move-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:move-ticket"))
+    opendiscord.actions.get("opendiscord:move-ticket").workers.add([
+        new api.ODWorker("opendiscord:move-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to move ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketMove").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketMove").emit([ticket,user,channel,reason])
            ticket.option = data

            //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-moved",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-moved",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-moved",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-moved",user.id,1,"increase")

            //get new channel properties
-            const channelPrefix = ticket.option.get("openticket:channel-prefix").value
-            const channelSuffix = ticket.get("openticket:channel-suffix").value
-            const channelCategory = ticket.option.get("openticket:channel-category").value
-            const channelBackupCategory = ticket.option.get("openticket:channel-category-backup").value
-            const rawClaimCategory = ticket.option.get("openticket:channel-categories-claimed").value.find((c) => c.user == user.id)
+            const channelPrefix = ticket.option.get("opendiscord:channel-prefix").value
+            const channelSuffix = ticket.get("opendiscord:channel-suffix").value
+            const channelCategory = ticket.option.get("opendiscord:channel-category").value
+            const channelBackupCategory = ticket.option.get("opendiscord:channel-category-backup").value
+            const rawClaimCategory = ticket.option.get("opendiscord:channel-categories-claimed").value.find((c) => c.user == user.id)
            const claimCategory = (rawClaimCategory) ? rawClaimCategory.category : null
-            const closeCategory = ticket.option.get("openticket:channel-category-closed").value
-            const channelDescription = ticket.option.get("openticket:channel-description").value
+            const closeCategory = ticket.option.get("opendiscord:channel-category-closed").value
+            const channelDescription = ticket.option.get("opendiscord:channel-description").value
            const channelName = channelPrefix+channelSuffix

            //handle category
@@ -38,16 +38,16 @@ export const registerActions = async () => {
                //use claim category
                category = claimCategory
                categoryMode = "claimed"
-            }else if (closeCategory != "" && ticket.get("openticket:closed").value){
+            }else if (closeCategory != "" && ticket.get("opendiscord:closed").value){
                //use close category
                category = closeCategory
                categoryMode = "closed"
            }else if (channelCategory != ""){
                //category enabled
-                const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
+                const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
                if (!normalCategory){
                    //default category was not found
-                    openticket.log("Ticket Move Error: Unable to find category! #1","error",[
+                    opendiscord.log("Ticket Move Error: Unable to find category! #1","error",[
                        {key:"categoryid",value:channelCategory},
                        {key:"backup",value:"false"}
                    ])
@@ -55,10 +55,10 @@ export const registerActions = async () => {
                    //default category was found
                    if (normalCategory.children.cache.size >= 50 && channelBackupCategory != ""){
                        //use backup category
-                        const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                        const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
                        if (!backupCategory){
                            //default category was not found
-                            openticket.log("Ticket Move Error: Unable to find category! #2","error",[
+                            opendiscord.log("Ticket Move Error: Unable to find category! #2","error",[
                                {key:"categoryid",value:channelBackupCategory},
                                {key:"backup",value:"true"}
                            ])
@@ -77,17 +77,17 @@ export const registerActions = async () => {
            try {
                //only move category when not the same.
                if (channel.parentId != category) await utilities.timedAwait(channel.setParent(category,{lockPermissions:false}),2500,(err) => {
-                    openticket.log("Failed to change channel category on ticket move","error")
+                    opendiscord.log("Failed to change channel category on ticket move","error")
                })
-                ticket.get("openticket:category-mode").value = categoryMode
-                ticket.get("openticket:category").value = category
+                ticket.get("opendiscord:category-mode").value = categoryMode
+                ticket.get("opendiscord:category").value = category
            }catch(e){
-                openticket.log("Unable to move ticket to 'moved category'!","error",[
+                opendiscord.log("Unable to move ticket to 'moved category'!","error",[
                    {key:"channel",value:"#"+channel.name},
                    {key:"channelid",value:channel.id,hidden:true},
                    {key:"categoryid",value:category ?? "/"}
                ])
-                openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
            }

            //handle permissions
@@ -97,9 +97,9 @@ export const registerActions = async () => {
                allow:[],
                deny:["ViewChannel","SendMessages","ReadMessageHistory"]
            }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
-            const optionAdmins = ticket.option.get("openticket:admins").value
-            const readonlyAdmins = ticket.option.get("openticket:admins-readonly").value
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
+            const optionAdmins = ticket.option.get("opendiscord:admins").value
+            const readonlyAdmins = ticket.option.get("opendiscord:admins-readonly").value

            globalAdmins.forEach((admin) => {
                permissions.push({
@@ -129,7 +129,7 @@ export const registerActions = async () => {
                })
            })
            //transfer all old user-participants over to the new ticket (creator & participants)
-            ticket.get("openticket:participants").value.forEach((p) => {
+            ticket.get("opendiscord:participants").value.forEach((p) => {
                if (p.type == "user") permissions.push({
                    type:discord.OverwriteType.Member,
                    id:p.id,
@@ -140,7 +140,7 @@ export const registerActions = async () => {
            try{
                await channel.permissionOverwrites.set(permissions)
            }catch{
-                openticket.log("Failed to reset channel permissions on ticket move!","error")
+                opendiscord.log("Failed to reset channel permissions on ticket move!","error")
            }

            //handle participants
@@ -151,60 +151,60 @@ export const registerActions = async () => {
                const id = permission.id as string
                participants.push({type,id})
            })
-            ticket.get("openticket:participants").value = participants
-            ticket.get("openticket:participants").refreshDatabase()
+            ticket.get("opendiscord:participants").value = participants
+            ticket.get("opendiscord:participants").refreshDatabase()

            //rename channel (and give error when crashed)
            const originalName = channel.name
            try{
                await utilities.timedAwait(channel.setName(channelName),2500,(err) => {
-                    openticket.log("Failed to rename channel on ticket move","error")
+                    opendiscord.log("Failed to rename channel on ticket move","error")
                })
            }catch(err){
-                await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-move",{guild,channel,user,originalName,newName:channelName})).message)
+                await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-move",{guild,channel,user,originalName,newName:channelName})).message)
            }
            try{
                if (channel.type == discord.ChannelType.GuildText) channel.setTopic(channelDescription)
            }catch{}

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket renaming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket renaming!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:move-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketMoved").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:move-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketMoved").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.moving.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.moving.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.moving.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" moved a ticket!","info",[
+            opendiscord.log(user.displayName+" moved a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -214,8 +214,8 @@ export const registerActions = async () => {
            ])
        })
    ])
-    openticket.actions.get("openticket:move-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:move-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,29 +1,29 @@
 ///////////////////////////////////////
 //TICKET PINNING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:pin-ticket"))
-    openticket.actions.get("openticket:pin-ticket").workers.add([
-        new api.ODWorker("openticket:pin-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:pin-ticket"))
+    opendiscord.actions.get("opendiscord:pin-ticket").workers.add([
+        new api.ODWorker("opendiscord:pin-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to pin ticket! Open Ticket doesn't support threads!")
            
-            await openticket.events.get("onTicketPin").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketPin").emit([ticket,user,channel,reason])

            //update ticket
-            ticket.get("openticket:pinned").value = true
-            ticket.get("openticket:pinned-by").value = user.id
-            ticket.get("openticket:pinned-on").value = new Date().getTime()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:pinned").value = true
+            ticket.get("opendiscord:pinned-by").value = user.id
+            ticket.get("opendiscord:pinned-on").value = new Date().getTime()
+            ticket.get("opendiscord:busy").value = true
            
            //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-pinned",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-pinned",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-pinned",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-pinned",user.id,1,"increase")

            //move to top of category
            if (channel.parent){
@@ -35,50 +35,50 @@ export const registerActions = async () => {
            const newName = "📌"+channel.name
            try{
                await utilities.timedAwait(channel.setName(newName),2500,(err) => {
-                    openticket.log("Failed to rename channel on ticket pin","error")
+                    opendiscord.log("Failed to rename channel on ticket pin","error")
                })
            }catch(err){
-                await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-pin",{guild,channel,user,originalName,newName})).message)
+                await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-pin",{guild,channel,user,originalName,newName})).message)
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket pinning!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket pinning!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"message",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:pin-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketPinned").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build(source,{guild,channel,user,ticket,reason})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketPinned").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.pinning.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.pinning.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.pinning.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" pinned a ticket!","info",[
+            opendiscord.log(user.displayName+" pinned a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -92,184 +92,184 @@ export const registerActions = async () => {

 export const registerVerifyBars = async () => {
    //PIN TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:pin-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:pin-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:pin-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:pin-ticket-ticket-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.pin

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already pinned
-            if (ticket.get("openticket:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
+            if (ticket.get("opendiscord:pinned").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start pinning ticket
            if (params.data == "reason"){
                //pin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:pin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:pin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
            }else{
                //pin without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:pin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:pin-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:pin-ticket-ticket-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
        })
    ])

    //PIN TICKET UNPIN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:pin-ticket-unpin-message",openticket.builders.messages.getSafe("openticket:verifybar-unpin-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:pin-ticket-unpin-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:pin-ticket-unpin-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-unpin-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:pin-ticket-unpin-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.pin

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already pinned
-            if (ticket.get("openticket:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
+            if (ticket.get("opendiscord:pinned").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start pinning ticket
            if (params.data == "reason"){
                //pin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:pin-ticket-reason").build("unpin-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:pin-ticket-reason").build("unpin-message",{guild,channel,user,ticket}))
            }else{
                //pin without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run("unpin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:pin-message").build("unpin-message",{guild,channel,user,ticket,reason:null}))
+                await opendiscord.actions.get("opendiscord:pin-ticket").run("unpin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build("unpin-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:pin-ticket-unpin-message").failure.add([
-        new api.ODWorker("openticket:back-to-unpin-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:pin-ticket-unpin-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-unpin-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:unpin-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])
-    openticket.actions.get("openticket:pin-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:pin-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,32 +1,32 @@
 ///////////////////////////////////////
 //REACTION ROLE SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:reaction-role"))
-    openticket.actions.get("openticket:reaction-role").workers.add([
-        new api.ODWorker("openticket:reaction-role",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:reaction-role"))
+    opendiscord.actions.get("opendiscord:reaction-role").workers.add([
+        new api.ODWorker("opendiscord:reaction-role",2,async (instance,params,source,cancel) => {
            const {guild,user,option,overwriteMode} = params
-            const role = openticket.roles.get(option.id)
+            const role = opendiscord.roles.get(option.id)
            if (!role) throw new api.ODSystemError("ODAction(ot:reaction-role) => Unknown reaction role (ODRole)")
            instance.role = role
-            const mode = (overwriteMode) ? overwriteMode : role.get("openticket:mode").value
+            const mode = (overwriteMode) ? overwriteMode : role.get("opendiscord:mode").value
            
-            await openticket.events.get("onRoleUpdate").emit([user,role])
+            await opendiscord.events.get("onRoleUpdate").emit([user,role])

            //get guild member
-            const member = await openticket.client.fetchGuildMember(guild,user.id)
+            const member = await opendiscord.client.fetchGuildMember(guild,user.id)
            if (!member) throw new api.ODSystemError("ODAction(ot:reaction-role) => User isn't a member of the server!")

            //get all roles
-            const roleIds = role.get("openticket:roles").value
+            const roleIds = role.get("opendiscord:roles").value
            const roles: discord.Role[] = []
            for (const id of roleIds){
-                const r = await openticket.client.fetchGuildRole(guild,id)
+                const r = await opendiscord.client.fetchGuildRole(guild,id)
                if (r) roles.push(r)
-                else openticket.log("Unable to find role in server!","warning",[
+                else opendiscord.log("Unable to find role in server!","warning",[
                    {key:"roleid",value:id}
                ])
            }
@@ -55,12 +55,12 @@ export const registerActions = async () => {
            //get roles to remove on add
            if (result.find((r) => r.action == "added")){
                //get all remove roles
-                const removeRoleIds = role.get("openticket:remove-roles-on-add").value
+                const removeRoleIds = role.get("opendiscord:remove-roles-on-add").value
                const removeRoles: discord.Role[] = []
                for (const id of removeRoleIds){
-                    const r = await openticket.client.fetchGuildRole(guild,id)
+                    const r = await opendiscord.client.fetchGuildRole(guild,id)
                    if (r) removeRoles.push(r)
-                    else openticket.log("Unable to find role in server!","warning",[
+                    else opendiscord.log("Unable to find role in server!","warning",[
                        {key:"roleid",value:id}
                    ])
                }
@@ -79,11 +79,11 @@ export const registerActions = async () => {

            //update instance & finish event
            instance.result = result
-            await openticket.events.get("afterRolesUpdated").emit([user,role])
+            await opendiscord.events.get("afterRolesUpdated").emit([user,role])
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,user,option} = params
-            openticket.log(user.displayName+" updated his roles!","info",[
+            opendiscord.log(user.displayName+" updated his roles!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"method",value:source},
@@ -1,71 +1,71 @@
 ///////////////////////////////////////
 //TICKET REMOVE USER SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:remove-ticket-user"))
-    openticket.actions.get("openticket:remove-ticket-user").workers.add([
-        new api.ODWorker("openticket:remove-ticket-user",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:remove-ticket-user"))
+    opendiscord.actions.get("opendiscord:remove-ticket-user").workers.add([
+        new api.ODWorker("opendiscord:remove-ticket-user",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to remove user from ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketUserRemove").emit([ticket,user,data,channel,reason])
+            await opendiscord.events.get("onTicketUserRemove").emit([ticket,user,data,channel,reason])
            
            //update ticket
-            const index = ticket.get("openticket:participants").value.findIndex((p) => p.type == "user" && p.id == data.id)
+            const index = ticket.get("opendiscord:participants").value.findIndex((p) => p.type == "user" && p.id == data.id)
            if (index < 0) return cancel()
-            ticket.get("openticket:participants").value.splice(index,1)
-            ticket.get("openticket:participants").refreshDatabase()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:participants").value.splice(index,1)
+            ticket.get("opendiscord:participants").refreshDatabase()
+            ticket.get("opendiscord:busy").value = true

            //update channel permissions
            try{
                await channel.permissionOverwrites.delete(data)
            }catch{
-                openticket.log("Failed to remove channel permission overwrites on remove-ticket-user","error")
+                opendiscord.log("Failed to remove channel permission overwrites on remove-ticket-user","error")
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket user removal!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket user removal!","error",[
                        {key:"channel",value:channel.id},
                        {key:"message",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:remove-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketUserRemoved").emit([ticket,user,data,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:remove-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketUserRemoved").emit([ticket,user,data,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.removing.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.removing.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.removing.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket,data} = params

-            openticket.log(user.displayName+" removed "+data.displayName+" from a ticket!","info",[
+            opendiscord.log(user.displayName+" removed "+data.displayName+" from a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -75,8 +75,8 @@ export const registerActions = async () => {
            ])
        })
    ])
-    openticket.actions.get("openticket:remove-ticket-user").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:remove-ticket-user").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,68 +1,68 @@
 ///////////////////////////////////////
 //TICKET RENAMING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:rename-ticket"))
-    openticket.actions.get("openticket:rename-ticket").workers.add([
-        new api.ODWorker("openticket:rename-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:rename-ticket"))
+    opendiscord.actions.get("opendiscord:rename-ticket").workers.add([
+        new api.ODWorker("opendiscord:rename-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to rename ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketRename").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketRename").emit([ticket,user,channel,reason])

            //rename channel (and give error when crashed)
            const originalName = channel.name
            try{
                await utilities.timedAwait(channel.setName(data),2500,(err) => {
-                    openticket.log("Failed to rename channel on ticket rename","error")
+                    opendiscord.log("Failed to rename channel on ticket rename","error")
                })
            }catch(err){
-                await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-rename",{guild,channel,user,originalName,newName:data})).message)
+                await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-rename",{guild,channel,user,originalName,newName:data})).message)
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket renaming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket renaming!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:rename-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketRenamed").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:rename-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketRenamed").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason,data} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.renaming.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.renaming.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.renaming.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" renamed a ticket!","info",[
+            opendiscord.log(user.displayName+" renamed a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -72,8 +72,8 @@ export const registerActions = async () => {
            ])
        })
    ])
-    openticket.actions.get("openticket:rename-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:rename-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,80 +1,82 @@
 ///////////////////////////////////////
 //TICKET REOPENING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:reopen-ticket"))
-    openticket.actions.get("openticket:reopen-ticket").workers.add([
-        new api.ODWorker("openticket:reopen-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:reopen-ticket"))
+    opendiscord.actions.get("opendiscord:reopen-ticket").workers.add([
+        new api.ODWorker("opendiscord:reopen-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to reopen ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketReopen").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketReopen").emit([ticket,user,channel,reason])

            //update ticket
-            ticket.get("openticket:closed").value = false
-            ticket.get("openticket:open").value = true
-            ticket.get("openticket:autoclosed").value = false
-            ticket.get("openticket:closed-by").value = null
-            ticket.get("openticket:closed-on").value = null
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:closed").value = false
+            ticket.get("opendiscord:open").value = true
+            ticket.get("opendiscord:autoclosed").value = false
+            ticket.get("opendiscord:closed-by").value = null
+            ticket.get("opendiscord:closed-on").value = null
+            ticket.get("opendiscord:busy").value = true

            //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-reopened",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-reopened",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-reopened",1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-reopened",user.id,1,"increase")

            //update category
-            const channelCategory = ticket.option.get("openticket:channel-category").value
-            const channelBackupCategory = ticket.option.get("openticket:channel-category-backup").value
-            if (channelCategory !== ""){
-                //category enabled
-                try {
-                    const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
-                    if (!normalCategory){
-                        //default category was not found
-                        openticket.log("Ticket Reopening Error: Unable to find category! #1","error",[
-                            {key:"categoryid",value:channelCategory},
-                            {key:"backup",value:"false"}
-                        ])
-                    }else{
-                        //default category was found
-                        if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
-                            //use backup category
-                            const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
-                            if (!backupCategory){
-                                //default category was not found
-                                openticket.log("Ticket Reopening Error: Unable to find category! #2","error",[
-                                    {key:"categoryid",value:channelBackupCategory},
-                                    {key:"backup",value:"true"}
-                                ])
-                            }else{
-                                //use backup category
-                                channel.setParent(backupCategory,{lockPermissions:false})
-                                ticket.get("openticket:category-mode").value = "backup"
-                                ticket.get("openticket:category").value = backupCategory.id
-                            }
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
+                const channelCategory = ticket.option.get("opendiscord:channel-category").value
+                const channelBackupCategory = ticket.option.get("opendiscord:channel-category-backup").value
+                if (channelCategory !== ""){
+                    //category enabled
+                    try {
+                        const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
+                        if (!normalCategory){
+                            //default category was not found
+                            opendiscord.log("Ticket Reopening Error: Unable to find category! #1","error",[
+                                {key:"categoryid",value:channelCategory},
+                                {key:"backup",value:"false"}
+                            ])
                        }else{
-                            //use default category
-                            channel.setParent(normalCategory,{lockPermissions:false})
-                            ticket.get("openticket:category-mode").value = "normal"
-                            ticket.get("openticket:category").value = normalCategory.id
+                            //default category was found
+                            if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
+                                //use backup category
+                                const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                                if (!backupCategory){
+                                    //default category was not found
+                                    opendiscord.log("Ticket Reopening Error: Unable to find category! #2","error",[
+                                        {key:"categoryid",value:channelBackupCategory},
+                                        {key:"backup",value:"true"}
+                                    ])
+                                }else{
+                                    //use backup category
+                                    channel.setParent(backupCategory,{lockPermissions:false})
+                                    ticket.get("opendiscord:category-mode").value = "backup"
+                                    ticket.get("opendiscord:category").value = backupCategory.id
+                                }
+                            }else{
+                                //use default category
+                                channel.setParent(normalCategory,{lockPermissions:false})
+                                ticket.get("opendiscord:category-mode").value = "normal"
+                                ticket.get("opendiscord:category").value = normalCategory.id
+                            }
                        }
+                    }catch(e){
+                        opendiscord.log("Unable to move ticket to 'reopened category'!","error",[
+                            {key:"channel",value:"#"+channel.name},
+                            {key:"channelid",value:channel.id,hidden:true},
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                    }
-                }catch(e){
-                    openticket.log("Unable to move ticket to 'reopened category'!","error",[
-                        {key:"channel",value:"#"+channel.name},
-                        {key:"channelid",value:channel.id,hidden:true},
-                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                }else{
+                    channel.setParent(null,{lockPermissions:false})
+                    ticket.get("opendiscord:category-mode").value = null
+                    ticket.get("opendiscord:category").value = null
                }
-            }else{
-                channel.setParent(null,{lockPermissions:false})
-                ticket.get("openticket:category-mode").value = null
-                ticket.get("openticket:category").value = null
            }

            //update permissions
@@ -84,9 +86,9 @@ export const registerActions = async () => {
                allow:[],
                deny:["ViewChannel","SendMessages","ReadMessageHistory"]
            }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
-            const optionAdmins = ticket.option.get("openticket:admins").value
-            const readonlyAdmins = ticket.option.get("openticket:admins-readonly").value
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
+            const optionAdmins = ticket.option.get("opendiscord:admins").value
+            const readonlyAdmins = ticket.option.get("opendiscord:admins-readonly").value

            globalAdmins.forEach((admin) => {
                permissions.push({
@@ -115,7 +117,7 @@ export const registerActions = async () => {
                    deny:["SendMessages","AddReactions","AttachFiles","SendPolls"]
                })
            })
-            ticket.get("openticket:participants").value.forEach((participant) => {
+            ticket.get("opendiscord:participants").value.forEach((participant) => {
                //all participants that aren't roles/admins
                if (participant.type == "user"){
                    permissions.push({
@@ -129,42 +131,42 @@ export const registerActions = async () => {
            channel.permissionOverwrites.set(permissions)

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket reopening!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket reopening!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:reopen-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketReopened").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build(source,{guild,channel,user,ticket,reason})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketReopened").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.reopening.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.reopening.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.reopening.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" reopened a ticket!","info",[
+            opendiscord.log(user.displayName+" reopened a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -178,272 +180,272 @@ export const registerActions = async () => {

 export const registerVerifyBars = async () => {
    //REOPEN TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:reopen-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:reopen-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:reopen-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-ticket-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.reopen

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not closed
-            if (!ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
+            if (!ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start reopening ticket
            if (params.data == "reason"){
                //reopen with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:reopen-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:reopen-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
            }else{
                //reopen without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:reopen-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-ticket-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
        })
    ])

    //REOPEN TICKET CLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:reopen-ticket-close-message",openticket.builders.messages.getSafe("openticket:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:reopen-ticket-close-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:reopen-ticket-close-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-close-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.reopen

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not closed
-            if (!ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
+            if (!ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start reopening ticket
            if (params.data == "reason"){
                //reopen with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:reopen-ticket-reason").build("close-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:reopen-ticket-reason").build("close-message",{guild,channel,user,ticket}))
            }else{
                //reopen without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("close-message",{guild,channel,user,ticket,reason:null}))
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("close-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:reopen-ticket-close-message").failure.add([
-        new api.ODWorker("openticket:back-to-close-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-close-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-close-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])

    //REOPEN TICKET AUTOCLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:reopen-ticket-autoclose-message",openticket.builders.messages.getSafe("openticket:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:reopen-ticket-autoclose-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:reopen-ticket-autoclose-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-autoclose-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.reopen

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not closed
-            if (!ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
+            if (!ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start reopening ticket
            if (params.data == "reason"){
                //reopen with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:reopen-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:reopen-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
            }else{
                //reopen without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:reopen-ticket-autoclose-message").failure.add([
-        new api.ODWorker("openticket:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-autoclose-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:autoclose-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-message").build("other",{guild,channel,user,ticket}))
        })
    ])
-    openticket.actions.get("openticket:reopen-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:reopen-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,115 +1,117 @@
 ///////////////////////////////////////
 //TICKET UNCLAIMING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:unclaim-ticket"))
-    openticket.actions.get("openticket:unclaim-ticket").workers.add([
-        new api.ODWorker("openticket:unclaim-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:unclaim-ticket"))
+    opendiscord.actions.get("opendiscord:unclaim-ticket").workers.add([
+        new api.ODWorker("opendiscord:unclaim-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to unclaim ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketUnclaim").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketUnclaim").emit([ticket,user,channel,reason])

            //update ticket
-            ticket.get("openticket:claimed").value = false
-            ticket.get("openticket:claimed-by").value = null
-            ticket.get("openticket:claimed-on").value = null
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:claimed").value = false
+            ticket.get("opendiscord:claimed-by").value = null
+            ticket.get("opendiscord:claimed-on").value = null
+            ticket.get("opendiscord:busy").value = true

            //update category
-            const channelCategory = ticket.option.get("openticket:channel-category").value
-            const channelBackupCategory = ticket.option.get("openticket:channel-category-backup").value
-            if (channelCategory !== ""){
-                //category enabled
-                try {
-                    const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
-                    if (!normalCategory){
-                        //default category was not found
-                        openticket.log("Ticket Unclaiming Error: Unable to find category! #1","error",[
-                            {key:"categoryid",value:channelCategory},
-                            {key:"backup",value:"false"}
-                        ])
-                    }else{
-                        //default category was found
-                        if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
-                            //use backup category
-                            const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
-                            if (!backupCategory){
-                                //default category was not found
-                                openticket.log("Ticket Unclaiming Error: Unable to find category! #2","error",[
-                                    {key:"categoryid",value:channelBackupCategory},
-                                    {key:"backup",value:"true"}
-                                ])
-                            }else{
-                                //use backup category
-                                channel.setParent(backupCategory,{lockPermissions:false})
-                                ticket.get("openticket:category-mode").value = "backup"
-                                ticket.get("openticket:category").value = backupCategory.id
-                            }
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
+                const channelCategory = ticket.option.get("opendiscord:channel-category").value
+                const channelBackupCategory = ticket.option.get("opendiscord:channel-category-backup").value
+                if (channelCategory !== ""){
+                    //category enabled
+                    try {
+                        const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
+                        if (!normalCategory){
+                            //default category was not found
+                            opendiscord.log("Ticket Unclaiming Error: Unable to find category! #1","error",[
+                                {key:"categoryid",value:channelCategory},
+                                {key:"backup",value:"false"}
+                            ])
                        }else{
-                            //use default category
-                            channel.setParent(normalCategory,{lockPermissions:false})
-                            ticket.get("openticket:category-mode").value = "normal"
-                            ticket.get("openticket:category").value = normalCategory.id
+                            //default category was found
+                            if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
+                                //use backup category
+                                const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                                if (!backupCategory){
+                                    //default category was not found
+                                    opendiscord.log("Ticket Unclaiming Error: Unable to find category! #2","error",[
+                                        {key:"categoryid",value:channelBackupCategory},
+                                        {key:"backup",value:"true"}
+                                    ])
+                                }else{
+                                    //use backup category
+                                    channel.setParent(backupCategory,{lockPermissions:false})
+                                    ticket.get("opendiscord:category-mode").value = "backup"
+                                    ticket.get("opendiscord:category").value = backupCategory.id
+                                }
+                            }else{
+                                //use default category
+                                channel.setParent(normalCategory,{lockPermissions:false})
+                                ticket.get("opendiscord:category-mode").value = "normal"
+                                ticket.get("opendiscord:category").value = normalCategory.id
+                            }
                        }
+                        
+                    }catch(e){
+                        opendiscord.log("Unable to move ticket to 'unclaimed category'!","error",[
+                            {key:"channel",value:"#"+channel.name},
+                            {key:"channelid",value:channel.id,hidden:true}
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                    }
-                    
-                }catch(e){
-                    openticket.log("Unable to move ticket to 'unclaimed category'!","error",[
-                        {key:"channel",value:"#"+channel.name},
-                        {key:"channelid",value:channel.id,hidden:true}
-                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                }else{
+                    channel.setParent(null,{lockPermissions:false})
+                    ticket.get("opendiscord:category-mode").value = null
+                    ticket.get("opendiscord:category").value = null
                }
-            }else{
-                channel.setParent(null,{lockPermissions:false})
-                ticket.get("openticket:category-mode").value = null
-                ticket.get("openticket:category").value = null
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket unclaiming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket unclaiming!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:unclaim-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketUnclaimed").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build(source,{guild,channel,user,ticket,reason})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketUnclaimed").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.claiming.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.claiming.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.claiming.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" unclaimed a ticket!","info",[
+            opendiscord.log(user.displayName+" unclaimed a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -123,184 +125,184 @@ export const registerActions = async () => {

 export const registerVerifyBars = async () => {
    //UNCLAIM TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unclaim-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unclaim-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unclaim-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-ticket-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.unclaim

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:unclaim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unclaim-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not claimed
-            if (!ticket.get("openticket:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
+            if (!ticket.get("opendiscord:claimed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start unclaiming ticket
            if (params.data == "reason"){
                //unclaim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unclaim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unclaim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
            }else{
                //unclaim without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unclaim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:unclaim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:unclaim-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-ticket-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
        })
    ])

    //UNCLAIM TICKET CLAIM MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unclaim-ticket-claim-message",openticket.builders.messages.getSafe("openticket:verifybar-claim-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unclaim-ticket-claim-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unclaim-ticket-claim-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-claim-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-claim-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.unclaim

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:unclaim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unclaim-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not claimed
-            if (!ticket.get("openticket:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
+            if (!ticket.get("opendiscord:claimed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start unclaiming ticket
            if (params.data == "reason"){
                //unclaim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unclaim-ticket-reason").build("claim-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unclaim-ticket-reason").build("claim-message",{guild,channel,user,ticket}))
            }else{
                //unclaim without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unclaim-ticket").run("claim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:unclaim-message").build("claim-message",{guild,channel,user,ticket,reason:null}))
+                await opendiscord.actions.get("opendiscord:unclaim-ticket").run("claim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build("claim-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:unclaim-ticket-claim-message").failure.add([
-        new api.ODWorker("openticket:back-to-claim-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-claim-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-claim-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:claim-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])
-    openticket.actions.get("openticket:unclaim-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:unclaim-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,25 +1,25 @@
 ///////////////////////////////////////
 //TICKET UNPINNING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:unpin-ticket"))
-    openticket.actions.get("openticket:unpin-ticket").workers.add([
-        new api.ODWorker("openticket:unpin-ticket",2,async (instance,params,source,cancel) => {
+    opendiscord.actions.add(new api.ODAction("opendiscord:unpin-ticket"))
+    opendiscord.actions.get("opendiscord:unpin-ticket").workers.add([
+        new api.ODWorker("opendiscord:unpin-ticket",2,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params
            if (channel.isThread()) throw new api.ODSystemError("Unable to unpin ticket! Open Ticket doesn't support threads!")

-            await openticket.events.get("onTicketUnpin").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketUnpin").emit([ticket,user,channel,reason])
            
            //update ticket
-            ticket.get("openticket:pinned").value = false
-            ticket.get("openticket:pinned-by").value = null
-            ticket.get("openticket:pinned-on").value = null
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:pinned").value = false
+            ticket.get("opendiscord:pinned-by").value = null
+            ticket.get("opendiscord:pinned-on").value = null
+            ticket.get("opendiscord:busy").value = true

            //rename channel (and give error when crashed)
            const originalName = channel.name
@@ -27,51 +27,51 @@ export const registerActions = async () => {
                const newName = originalName.replace("📌","");
                try{
                    await utilities.timedAwait(channel.setName(newName),2500,(err) => {
-                        openticket.log("Failed to rename channel on ticket unpin","error")
+                        opendiscord.log("Failed to rename channel on ticket unpin","error")
                    })
                }catch(err){
-                    await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-unpin",{guild,channel,user,originalName,newName})).message)
+                    await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-unpin",{guild,channel,user,originalName,newName})).message)
                }
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket unpinning!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket unpinning!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }

            //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:unpin-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
-            await openticket.events.get("afterTicketUnpinned").emit([ticket,user,channel,reason])
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build(source,{guild,channel,user,ticket,reason})).message)
+            ticket.get("opendiscord:busy").value = false
+            await opendiscord.events.get("afterTicketUnpinned").emit([ticket,user,channel,reason])
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user,ticket,reason} = params

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.pinning.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
            }

            //to dm
-            const creator = await openticket.tickets.getTicketUser(ticket,"creator")
-            if (creator && generalConfig.data.system.messages.pinning.dm) await openticket.client.sendUserDm(creator,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.pinning.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
        }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
            const {guild,channel,user,ticket} = params

-            openticket.log(user.displayName+" unpinned a ticket!","info",[
+            opendiscord.log(user.displayName+" unpinned a ticket!","info",[
                {key:"user",value:user.username},
                {key:"userid",value:user.id,hidden:true},
                {key:"channel",value:"#"+channel.name},
@@ -85,184 +85,184 @@ export const registerActions = async () => {

 export const registerVerifyBars = async () => {
    //UNPIN TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unpin-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unpin-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unpin-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-ticket-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.unpin

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:unpin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unpin-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not pinned
-            if (!ticket.get("openticket:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
+            if (!ticket.get("opendiscord:pinned").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start unpining ticket
            if (params.data == "reason"){
                //unpin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unpin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unpin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
            }else{
                //unpin without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unpin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:unpin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:unpin-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-ticket-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
        })
    ])

    //UNPIN TICKET PIN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unpin-ticket-pin-message",openticket.builders.messages.getSafe("openticket:verifybar-pin-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unpin-ticket-pin-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unpin-ticket-pin-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-pin-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-pin-message").success.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.unpin

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:unpin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unpin-ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not pinned
-            if (!ticket.get("openticket:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
+            if (!ticket.get("opendiscord:pinned").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            //start unpinning ticket
            if (params.data == "reason"){
                //unpin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unpin-ticket-reason").build("pin-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unpin-ticket-reason").build("pin-message",{guild,channel,user,ticket}))
            }else{
                //unpin without reason
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unpin-ticket").run("pin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:unpin-message").build("pin-message",{guild,channel,user,ticket,reason:null}))
+                await opendiscord.actions.get("opendiscord:unpin-ticket").run("pin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build("pin-message",{guild,channel,user,ticket,reason:null}))
            }
        })
    ])
-    openticket.verifybars.get("openticket:unpin-ticket-pin-message").failure.add([
-        new api.ODWorker("openticket:back-to-pin-message",0,async (instance,params,source,cancel) => {
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-pin-message").failure.add([
+        new api.ODWorker("opendiscord:back-to-pin-message",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            const {verifybarMessage} = params
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }

            const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
            const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)

-            await instance.update(await openticket.builders.messages.getSafe("openticket:pin-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build("other",{guild,channel,user,ticket,reason}))
        })
    ])
-    openticket.actions.get("openticket:unpin-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:unpin-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
        //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
    })
 }
@@ -1,12 +1,12 @@
 ///////////////////////////////////////
 //BUTTON BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const buttons = openticket.builders.buttons
-const lang = openticket.languages
-const generalConfig = openticket.configs.get("openticket:general")
+const buttons = opendiscord.builders.buttons
+const lang = opendiscord.languages
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerAllButtons = async () => {
    verifybarButtons()
@@ -20,12 +20,12 @@ export const registerAllButtons = async () => {

 const verifybarButtons = () => {
    //VERIFYBAR SUCCESS
-    buttons.add(new api.ODButton("openticket:verifybar-success"))
-    buttons.get("openticket:verifybar-success").workers.add(
-        new api.ODWorker("openticket:verifybar-success",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:verifybar-success"))
+    buttons.get("opendiscord:verifybar-success").workers.add(
+        new api.ODWorker("opendiscord:verifybar-success",0,async (instance,params) => {
            const {verifybar,customData,customColor,customLabel,customEmoji} = params

-            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:openticket:verifybar-success => customData exceeds 40 characters limit!")
+            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:opendiscord:verifybar-success => customData exceeds 40 characters limit!")

            const newData = (customData) ? "_"+customData : ""
            const newColor = customColor ?? "gray"
@@ -41,12 +41,12 @@ const verifybarButtons = () => {
    )

    //VERIFYBAR FAILURE
-    buttons.add(new api.ODButton("openticket:verifybar-failure"))
-    buttons.get("openticket:verifybar-failure").workers.add(
-        new api.ODWorker("openticket:verifybar-failure",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:verifybar-failure"))
+    buttons.get("opendiscord:verifybar-failure").workers.add(
+        new api.ODWorker("opendiscord:verifybar-failure",0,async (instance,params) => {
            const {verifybar,customData,customColor,customLabel,customEmoji} = params

-            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:openticket:verifybar-success => customData exceeds 40 characters limit!")
+            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:opendiscord:verifybar-success => customData exceeds 40 characters limit!")

            const newData = (customData) ? "_"+customData : ""
            const newColor = customColor ?? "gray"
@@ -64,9 +64,9 @@ const verifybarButtons = () => {

 const errorButtons = () => {
    //ERROR TICKET DEPRECATED TRANSCRIPT
-    buttons.add(new api.ODButton("openticket:error-ticket-deprecated-transcript"))
-    buttons.get("openticket:error-ticket-deprecated-transcript").workers.add(
-        new api.ODWorker("openticket:error-ticket-deprecated-transcript",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:error-ticket-deprecated-transcript"))
+    buttons.get("opendiscord:error-ticket-deprecated-transcript").workers.add(
+        new api.ODWorker("opendiscord:error-ticket-deprecated-transcript",0,async (instance,params) => {
            
            instance.setCustomId("od:error-ticket-deprecated-transcript")
            instance.setMode("button")
@@ -79,11 +79,11 @@ const errorButtons = () => {

 const helpMenuButtons = () => {
    //HELP MENU PAGE
-    buttons.add(new api.ODButton("openticket:help-menu-page"))
-    buttons.get("openticket:help-menu-page").workers.add(
-        new api.ODWorker("openticket:help-menu-page",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:help-menu-page"))
+    buttons.get("opendiscord:help-menu-page").workers.add(
+        new api.ODWorker("opendiscord:help-menu-page",0,async (instance,params) => {
            const {mode,page} = params
-            const totalPages = (await openticket.helpmenu.render(mode)).length
+            const totalPages = (await opendiscord.helpmenu.render(mode)).length
            const pageText = (page+1).toString()+"/"+totalPages.toString()

            instance.setCustomId("od:help-menu-page_"+page.toString())
@@ -95,9 +95,9 @@ const helpMenuButtons = () => {
    )

    //HELP MENU SWITCH
-    buttons.add(new api.ODButton("openticket:help-menu-switch"))
-    buttons.get("openticket:help-menu-switch").workers.add(
-        new api.ODWorker("openticket:help-menu-switch",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:help-menu-switch"))
+    buttons.get("opendiscord:help-menu-switch").workers.add(
+        new api.ODWorker("opendiscord:help-menu-switch",0,async (instance,params) => {
            const {mode} = params

            instance.setCustomId("od:help-menu-switch_"+mode)
@@ -109,9 +109,9 @@ const helpMenuButtons = () => {
    )

    //HELP MENU PREVIOUS
-    buttons.add(new api.ODButton("openticket:help-menu-previous"))
-    buttons.get("openticket:help-menu-previous").workers.add(
-        new api.ODWorker("openticket:help-menu-previous",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:help-menu-previous"))
+    buttons.get("opendiscord:help-menu-previous").workers.add(
+        new api.ODWorker("opendiscord:help-menu-previous",0,async (instance,params) => {
            const {page} = params
            
            instance.setCustomId("od:help-menu-previous")
@@ -123,11 +123,11 @@ const helpMenuButtons = () => {
    )

    //HELP MENU NEXT
-    buttons.add(new api.ODButton("openticket:help-menu-next"))
-    buttons.get("openticket:help-menu-next").workers.add(
-        new api.ODWorker("openticket:help-menu-next",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:help-menu-next"))
+    buttons.get("opendiscord:help-menu-next").workers.add(
+        new api.ODWorker("opendiscord:help-menu-next",0,async (instance,params) => {
            const {mode,page} = params
-            const totalPages = (await openticket.helpmenu.render(mode)).length
+            const totalPages = (await opendiscord.helpmenu.render(mode)).length
            
            instance.setCustomId("od:help-menu-next")
            instance.setMode("button")
@@ -140,55 +140,55 @@ const helpMenuButtons = () => {

 const panelButtons = () => {
    //TICKET OPTION
-    buttons.add(new api.ODButton("openticket:ticket-option"))
-    buttons.get("openticket:ticket-option").workers.add(
-        new api.ODWorker("openticket:ticket-option",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:ticket-option"))
+    buttons.get("opendiscord:ticket-option").workers.add(
+        new api.ODWorker("opendiscord:ticket-option",0,async (instance,params) => {
            const {panel,option} = params
            
            instance.setCustomId("od:ticket-option_"+panel.id.value+"_"+option.id.value)
            instance.setMode("button")
-            instance.setColor(option.get("openticket:button-color").value)
-            if (option.get("openticket:button-emoji").value) instance.setEmoji(option.get("openticket:button-emoji").value)
-            if (option.get("openticket:button-label").value) instance.setLabel(option.get("openticket:button-label").value)
-            if (!option.get("openticket:button-emoji").value && !option.get("openticket:button-label").value) instance.setLabel("<"+option.id.value+">")
+            instance.setColor(option.get("opendiscord:button-color").value)
+            if (option.get("opendiscord:button-emoji").value) instance.setEmoji(option.get("opendiscord:button-emoji").value)
+            if (option.get("opendiscord:button-label").value) instance.setLabel(option.get("opendiscord:button-label").value)
+            if (!option.get("opendiscord:button-emoji").value && !option.get("opendiscord:button-label").value) instance.setLabel("<"+option.id.value+">")
        })
    )

    //WEBSITE OPTION
-    buttons.add(new api.ODButton("openticket:website-option"))
-    buttons.get("openticket:website-option").workers.add(
-        new api.ODWorker("openticket:website-option",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:website-option"))
+    buttons.get("opendiscord:website-option").workers.add(
+        new api.ODWorker("opendiscord:website-option",0,async (instance,params) => {
            const {panel,option} = params
            
            instance.setMode("url")
-            instance.setUrl(option.get("openticket:url").value)
-            if (option.get("openticket:button-emoji").value) instance.setEmoji(option.get("openticket:button-emoji").value)
-            if (option.get("openticket:button-label").value) instance.setLabel(option.get("openticket:button-label").value)
-            if (!option.get("openticket:button-emoji").value && !option.get("openticket:button-label").value) instance.setLabel("<"+option.id.value+">")
+            instance.setUrl(option.get("opendiscord:url").value)
+            if (option.get("opendiscord:button-emoji").value) instance.setEmoji(option.get("opendiscord:button-emoji").value)
+            if (option.get("opendiscord:button-label").value) instance.setLabel(option.get("opendiscord:button-label").value)
+            if (!option.get("opendiscord:button-emoji").value && !option.get("opendiscord:button-label").value) instance.setLabel("<"+option.id.value+">")
        })
    )

    //ROLE OPTION
-    buttons.add(new api.ODButton("openticket:role-option"))
-    buttons.get("openticket:role-option").workers.add(
-        new api.ODWorker("openticket:role-option",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:role-option"))
+    buttons.get("opendiscord:role-option").workers.add(
+        new api.ODWorker("opendiscord:role-option",0,async (instance,params) => {
            const {panel,option} = params
            
            instance.setCustomId("od:role-option_"+panel.id.value+"_"+option.id.value)
            instance.setMode("button")
-            instance.setColor(option.get("openticket:button-color").value)
-            if (option.get("openticket:button-emoji").value) instance.setEmoji(option.get("openticket:button-emoji").value)
-            if (option.get("openticket:button-label").value) instance.setLabel(option.get("openticket:button-label").value)
-            if (!option.get("openticket:button-emoji").value && !option.get("openticket:button-label").value) instance.setLabel("<"+option.id.value+">")
+            instance.setColor(option.get("opendiscord:button-color").value)
+            if (option.get("opendiscord:button-emoji").value) instance.setEmoji(option.get("opendiscord:button-emoji").value)
+            if (option.get("opendiscord:button-label").value) instance.setLabel(option.get("opendiscord:button-label").value)
+            if (!option.get("opendiscord:button-emoji").value && !option.get("opendiscord:button-label").value) instance.setLabel("<"+option.id.value+">")
        })
    )
 }

 const ticketButtons = () => {
    //VISIT TICKET
-    buttons.add(new api.ODButton("openticket:visit-ticket"))
-    buttons.get("openticket:visit-ticket").workers.add(
-        new api.ODWorker("openticket:visit-ticket",0,async (instance,params) => {
+    buttons.add(new api.ODButton("opendiscord:visit-ticket"))
+    buttons.get("opendiscord:visit-ticket").workers.add(
+        new api.ODWorker("opendiscord:visit-ticket",0,async (instance,params) => {
            const {guild,channel,ticket} = params
            
            instance.setMode("url")
@@ -199,9 +199,9 @@ const ticketButtons = () => {
    )

    //CLOSE TICKET
-    buttons.add(new api.ODButton("openticket:close-ticket"))
-    buttons.get("openticket:close-ticket").workers.add(
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:close-ticket"))
+    buttons.get("opendiscord:close-ticket").workers.add(
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source) => {
            const {guild,channel,ticket} = params

            instance.setMode("button")
@@ -213,9 +213,9 @@ const ticketButtons = () => {
    )

    //DELETE TICKET
-    buttons.add(new api.ODButton("openticket:delete-ticket"))
-    buttons.get("openticket:delete-ticket").workers.add(
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:delete-ticket"))
+    buttons.get("opendiscord:delete-ticket").workers.add(
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source) => {
            const {guild,channel,ticket} = params

            instance.setMode("button")
@@ -227,9 +227,9 @@ const ticketButtons = () => {
    )

    //REOPEN TICKET
-    buttons.add(new api.ODButton("openticket:reopen-ticket"))
-    buttons.get("openticket:reopen-ticket").workers.add(
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:reopen-ticket"))
+    buttons.get("opendiscord:reopen-ticket").workers.add(
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source) => {
            const {guild,channel,ticket} = params

            instance.setMode("button")
@@ -241,9 +241,9 @@ const ticketButtons = () => {
    )

    //CLAIM TICKET
-    buttons.add(new api.ODButton("openticket:claim-ticket"))
-    buttons.get("openticket:claim-ticket").workers.add(
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:claim-ticket"))
+    buttons.get("opendiscord:claim-ticket").workers.add(
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source) => {
            const {guild,channel,ticket} = params

            instance.setMode("button")
@@ -255,9 +255,9 @@ const ticketButtons = () => {
    )

    //UNCLAIM TICKET
-    buttons.add(new api.ODButton("openticket:unclaim-ticket"))
-    buttons.get("openticket:unclaim-ticket").workers.add(
-        new api.ODWorker("openticket:unclaim-ticket",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:unclaim-ticket"))
+    buttons.get("opendiscord:unclaim-ticket").workers.add(
+        new api.ODWorker("opendiscord:unclaim-ticket",0,async (instance,params,source) => {
            const {guild,channel,ticket} = params

            instance.setMode("button")
@@ -269,9 +269,9 @@ const ticketButtons = () => {
    )

    //PIN TICKET
-    buttons.add(new api.ODButton("openticket:pin-ticket"))
-    buttons.get("openticket:pin-ticket").workers.add(
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:pin-ticket"))
+    buttons.get("opendiscord:pin-ticket").workers.add(
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source) => {
            const {guild,channel,ticket} = params

            instance.setMode("button")
@@ -283,9 +283,9 @@ const ticketButtons = () => {
    )

    //UNPIN TICKET
-    buttons.add(new api.ODButton("openticket:unpin-ticket"))
-    buttons.get("openticket:unpin-ticket").workers.add(
-        new api.ODWorker("openticket:unpin-ticket",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:unpin-ticket"))
+    buttons.get("opendiscord:unpin-ticket").workers.add(
+        new api.ODWorker("opendiscord:unpin-ticket",0,async (instance,params,source) => {
            const {guild,channel,ticket} = params

            instance.setMode("button")
@@ -299,22 +299,22 @@ const ticketButtons = () => {

 const transcriptButtons = () => {
    //TRANSCRIPT HTML VISIT
-    buttons.add(new api.ODButton("openticket:transcript-html-visit"))
-    buttons.get("openticket:transcript-html-visit").workers.add(
-        new api.ODWorker("openticket:transcript-html-visit",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:transcript-html-visit"))
+    buttons.get("opendiscord:transcript-html-visit").workers.add(
+        new api.ODWorker("opendiscord:transcript-html-visit",0,async (instance,params,source) => {
            const {result} = params
            instance.setMode("url")
            if (result.data) instance.setUrl(result.data.url)
-            else throw new api.ODSystemError("ODButton:openticket:transcript-html-visit => Missing Transcript Result Data!")
+            else throw new api.ODSystemError("ODButton:opendiscord:transcript-html-visit => Missing Transcript Result Data!")
            instance.setEmoji("📄")
            instance.setLabel(lang.getTranslation("transcripts.success.visit"))
        })
    )

    //TRANSCRIPT ERROR RETRY
-    buttons.add(new api.ODButton("openticket:transcript-error-retry"))
-    buttons.get("openticket:transcript-error-retry").workers.add(
-        new api.ODWorker("openticket:transcript-error-retry",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:transcript-error-retry"))
+    buttons.get("opendiscord:transcript-error-retry").workers.add(
+        new api.ODWorker("opendiscord:transcript-error-retry",0,async (instance,params,source) => {
            instance.setMode("button")
            instance.setCustomId("od:transcript-error-retry_"+source)
            instance.setColor("gray")
@@ -324,9 +324,9 @@ const transcriptButtons = () => {
    )

    //TRANSCRIPT ERROR CONTINUE
-    buttons.add(new api.ODButton("openticket:transcript-error-continue"))
-    buttons.get("openticket:transcript-error-continue").workers.add(
-        new api.ODWorker("openticket:transcript-error-continue",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:transcript-error-continue"))
+    buttons.get("opendiscord:transcript-error-continue").workers.add(
+        new api.ODWorker("opendiscord:transcript-error-continue",0,async (instance,params,source) => {
            instance.setMode("button")
            instance.setCustomId("od:transcript-error-continue_"+source)
            instance.setColor("red")
@@ -338,9 +338,9 @@ const transcriptButtons = () => {

 const clearButtons = () => {
    //CLEAR CONTINUE
-    buttons.add(new api.ODButton("openticket:clear-continue"))
-    buttons.get("openticket:clear-continue").workers.add(
-        new api.ODWorker("openticket:clear-continue",0,async (instance,params,source) => {
+    buttons.add(new api.ODButton("opendiscord:clear-continue"))
+    buttons.get("opendiscord:clear-continue").workers.add(
+        new api.ODWorker("opendiscord:clear-continue",0,async (instance,params,source) => {
            instance.setMode("button")
            instance.setCustomId("od:clear-continue_"+source+"_"+params.filter)
            instance.setColor("red")
@@ -1,10 +1,10 @@
 ///////////////////////////////////////
 //DROPDOWN BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const dropdowns = openticket.builders.dropdowns
+const dropdowns = opendiscord.builders.dropdowns

 export const registerAllDropdowns = async () => {
    panelDropdowns()
@@ -12,16 +12,18 @@ export const registerAllDropdowns = async () => {

 const panelDropdowns = () => {
    //TICKET OPTION
-    dropdowns.add(new api.ODDropdown("openticket:panel-dropdown-tickets"))
-    dropdowns.get("openticket:panel-dropdown-tickets").workers.add(
-        new api.ODWorker("openticket:panel-dropdown-tickets",0,async (instance,params) => {
+    dropdowns.add(new api.ODDropdown("opendiscord:panel-dropdown-tickets"))
+    dropdowns.get("opendiscord:panel-dropdown-tickets").workers.add(
+        new api.ODWorker("opendiscord:panel-dropdown-tickets",0,async (instance,params) => {
            const {panel,options} = params
            
            const parsedOptions: api.ODDropdownData["options"] = options.map((option) => {
-                const desc = option.get("openticket:description").value.substring(0,100)
-                const emoji = option.get("openticket:button-emoji").value
+                const label = option.get("opendiscord:button-label").value.substring(0,100)
+                const desc = option.get("opendiscord:description").value.substring(0,100)
+                const emoji = option.get("opendiscord:button-emoji").value
+                
                return {
-                    label:option.get("openticket:button-label").value.substring(0,100),
+                    label:(label.length > 0) ? label : "<no-label-provided>",
                    value:"od:ticket-option_"+panel.id.value+"_"+option.id.value,
                    emoji:(emoji.length > 0) ? emoji : undefined,
                    description:(desc.length > 0) ? desc : undefined,
@@ -33,7 +35,7 @@ const panelDropdowns = () => {
            instance.setType("string")
            instance.setMaxValues(1)
            instance.setMinValues(0)
-            instance.setPlaceholder(panel.get("openticket:dropdown-placeholder").value)
+            instance.setPlaceholder(panel.get("opendiscord:dropdown-placeholder").value)
            instance.setOptions(parsedOptions)
        })
    )
@@ -1,13 +1,13 @@
 ///////////////////////////////////////
 //EMBED BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 import nodepath from "path"

-const embeds = openticket.builders.embeds
-const lang = openticket.languages
-const generalConfig = openticket.configs.get("openticket:general")
+const embeds = opendiscord.builders.embeds
+const lang = opendiscord.languages
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerAllEmbeds = async () => {
    errorEmbeds()
@@ -34,9 +34,9 @@ const getMethodFromSource = (source:"slash"|"text"|"button"|"dropdown"|"modal"|"

 const errorEmbeds = () => {
    //ERROR
-    embeds.add(new api.ODEmbed("openticket:error"))
-    embeds.get("openticket:error").workers.add(
-        new api.ODWorker("openticket:error",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error"))
+    embeds.get("opendiscord:error").workers.add(
+        new api.ODWorker("opendiscord:error",0,async (instance,params,source) => {
            const {user,error,layout} = params
            
            const method = getMethodFromSource(source)
@@ -51,9 +51,9 @@ const errorEmbeds = () => {
    )

    //ERROR OPTION MISSING
-    embeds.add(new api.ODEmbed("openticket:error-option-missing"))
-    embeds.get("openticket:error-option-missing").workers.add(
-        new api.ODWorker("openticket:error-option-missing",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-option-missing"))
+    embeds.get("opendiscord:error-option-missing").workers.add(
+        new api.ODWorker("opendiscord:error-option-missing",0,async (instance,params) => {
            const {user,error} = params
            
            const options = error.command.builder.options ?? []
@@ -83,9 +83,9 @@ const errorEmbeds = () => {
    )

    //ERROR OPTION INVALID
-    embeds.add(new api.ODEmbed("openticket:error-option-invalid"))
-    embeds.get("openticket:error-option-invalid").workers.add(
-        new api.ODWorker("openticket:error-option-invalid",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-option-invalid"))
+    embeds.get("opendiscord:error-option-invalid").workers.add(
+        new api.ODWorker("opendiscord:error-option-invalid",0,async (instance,params) => {
            const {user,error} = params
            
            const options = error.command.builder.options ?? []
@@ -138,9 +138,9 @@ const errorEmbeds = () => {
    )

    //ERROR UNKNOWN COMMAND
-    embeds.add(new api.ODEmbed("openticket:error-unknown-command"))
-    embeds.get("openticket:error-unknown-command").workers.add(
-        new api.ODWorker("openticket:error-unknown-command",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-unknown-command"))
+    embeds.get("opendiscord:error-unknown-command").workers.add(
+        new api.ODWorker("opendiscord:error-unknown-command",0,async (instance,params) => {
            const {user} = params
            
            instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -151,9 +151,9 @@ const errorEmbeds = () => {
    )

    //ERROR NO PERMISSIONS
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions"))
-    embeds.get("openticket:error-no-permissions").workers.add(
-        new api.ODWorker("openticket:error-no-permissions",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions"))
+    embeds.get("opendiscord:error-no-permissions").workers.add(
+        new api.ODWorker("opendiscord:error-no-permissions",0,async (instance,params,source) => {
            const {user,permissions} = params
            
            const method = getMethodFromSource(source)
@@ -177,9 +177,9 @@ const errorEmbeds = () => {
    )

    //ERROR NO PERMISSIONS COOLDOWN
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions-cooldown"))
-    embeds.get("openticket:error-no-permissions-cooldown").workers.add(
-        new api.ODWorker("openticket:error-no-permissions-cooldown",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions-cooldown"))
+    embeds.get("opendiscord:error-no-permissions-cooldown").workers.add(
+        new api.ODWorker("opendiscord:error-no-permissions-cooldown",0,async (instance,params,source) => {
            const {user} = params
            
            const method = getMethodFromSource(source)
@@ -193,9 +193,9 @@ const errorEmbeds = () => {
    )

    //ERROR NO PERMISSIONS BLACKLISTED
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions-blacklisted"))
-    embeds.get("openticket:error-no-permissions-blacklisted").workers.add(
-        new api.ODWorker("openticket:error-no-permissions-blacklisted",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions-blacklisted"))
+    embeds.get("opendiscord:error-no-permissions-blacklisted").workers.add(
+        new api.ODWorker("opendiscord:error-no-permissions-blacklisted",0,async (instance,params,source) => {
            const {user} = params
            
            const method = getMethodFromSource(source)
@@ -208,9 +208,9 @@ const errorEmbeds = () => {
    )

    //ERROR NO PERMISSIONS LIMITS
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions-limits"))
-    embeds.get("openticket:error-no-permissions-limits").workers.add(
-        new api.ODWorker("openticket:error-no-permissions-limits",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions-limits"))
+    embeds.get("opendiscord:error-no-permissions-limits").workers.add(
+        new api.ODWorker("opendiscord:error-no-permissions-limits",0,async (instance,params,source) => {
            const {user,limit} = params
            
            instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -224,9 +224,9 @@ const errorEmbeds = () => {
    )

    //ERROR RESPONDER TIMEOUT
-    embeds.add(new api.ODEmbed("openticket:error-responder-timeout"))
-    embeds.get("openticket:error-responder-timeout").workers.add(
-        new api.ODWorker("openticket:error-responder-timeout",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-responder-timeout"))
+    embeds.get("opendiscord:error-responder-timeout").workers.add(
+        new api.ODWorker("opendiscord:error-responder-timeout",0,async (instance,params,source) => {
            const {user} = params
            
            const method = getMethodFromSource(source)
@@ -241,9 +241,9 @@ const errorEmbeds = () => {
    )

    //ERROR TICKET UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:error-ticket-unknown"))
-    embeds.get("openticket:error-ticket-unknown").workers.add(
-        new api.ODWorker("openticket:error-ticket-unknown",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-ticket-unknown"))
+    embeds.get("opendiscord:error-ticket-unknown").workers.add(
+        new api.ODWorker("opendiscord:error-ticket-unknown",0,async (instance,params,source) => {
            const {user} = params

            instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -255,9 +255,9 @@ const errorEmbeds = () => {
    )

    //ERROR TICKET DEPRECATED
-    embeds.add(new api.ODEmbed("openticket:error-ticket-deprecated"))
-    embeds.get("openticket:error-ticket-deprecated").workers.add(
-        new api.ODWorker("openticket:error-ticket-deprecated",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-ticket-deprecated"))
+    embeds.get("opendiscord:error-ticket-deprecated").workers.add(
+        new api.ODWorker("opendiscord:error-ticket-deprecated",0,async (instance,params,source) => {
            const {user} = params

            instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -269,14 +269,14 @@ const errorEmbeds = () => {
    )

    //ERROR OPTION UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:error-option-unknown"))
-    embeds.get("openticket:error-option-unknown").workers.add(
-        new api.ODWorker("openticket:error-option-unknown",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-option-unknown"))
+    embeds.get("opendiscord:error-option-unknown").workers.add(
+        new api.ODWorker("opendiscord:error-option-unknown",0,async (instance,params,source) => {
            const {user} = params

-            const renderedTicketOptions = openticket.options.getAll().map((option) => {
-                if (option instanceof api.ODTicketOption && option.exists("openticket:name")){
-                    return "- **"+option.get("openticket:name").value+":** `"+option.id.value+"`"
+            const renderedTicketOptions = opendiscord.options.getAll().map((option) => {
+                if (option instanceof api.ODTicketOption && option.exists("opendiscord:name")){
+                    return "- **"+option.get("opendiscord:name").value+":** `"+option.id.value+"`"
                }else return "- `"+option.id.value+"`"
            }).join("\n")

@@ -289,14 +289,14 @@ const errorEmbeds = () => {
    )

    //ERROR PANEL UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:error-panel-unknown"))
-    embeds.get("openticket:error-panel-unknown").workers.add(
-        new api.ODWorker("openticket:error-panel-unknown",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-panel-unknown"))
+    embeds.get("opendiscord:error-panel-unknown").workers.add(
+        new api.ODWorker("opendiscord:error-panel-unknown",0,async (instance,params,source) => {
            const {user} = params

-            const renderedPanels = openticket.panels.getAll().map((panel) => {
-                if (panel.exists("openticket:name")){
-                    return "- **"+panel.get("openticket:name").value+":** `"+panel.id.value+"`"
+            const renderedPanels = opendiscord.panels.getAll().map((panel) => {
+                if (panel.exists("opendiscord:name")){
+                    return "- **"+panel.get("opendiscord:name").value+":** `"+panel.id.value+"`"
                }else return "- `"+panel.id.value+"`"
            }).join("\n")

@@ -309,9 +309,9 @@ const errorEmbeds = () => {
    )

    //ERROR NOT IN GUILD
-    embeds.add(new api.ODEmbed("openticket:error-not-in-guild"))
-    embeds.get("openticket:error-not-in-guild").workers.add(
-        new api.ODWorker("openticket:error-not-in-guild",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-not-in-guild"))
+    embeds.get("opendiscord:error-not-in-guild").workers.add(
+        new api.ODWorker("opendiscord:error-not-in-guild",0,async (instance,params,source) => {
            const {user} = params

            const method = getMethodFromSource(source)
@@ -324,9 +324,9 @@ const errorEmbeds = () => {
    )

    //ERROR CHANNEL RENAME
-    embeds.add(new api.ODEmbed("openticket:error-channel-rename"))
-    embeds.get("openticket:error-channel-rename").workers.add(
-        new api.ODWorker("openticket:error-channel-rename",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-channel-rename"))
+    embeds.get("opendiscord:error-channel-rename").workers.add(
+        new api.ODWorker("opendiscord:error-channel-rename",0,async (instance,params,source) => {
            const {channel,user,originalName,newName} = params
            
            const method = (source == "ticket-move" || source == "ticket-pin" || source == "ticket-rename" || source == "ticket-unpin") ? source : getMethodFromSource(source)
@@ -344,9 +344,9 @@ const errorEmbeds = () => {
    )

    //ERROR TICKET BUSY
-    embeds.add(new api.ODEmbed("openticket:error-ticket-busy"))
-    embeds.get("openticket:error-ticket-busy").workers.add(
-        new api.ODWorker("openticket:error-ticket-busy",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:error-ticket-busy"))
+    embeds.get("opendiscord:error-ticket-busy").workers.add(
+        new api.ODWorker("opendiscord:error-ticket-busy",0,async (instance,params,source) => {
            const {user} = params
            
            const method = getMethodFromSource(source)
@@ -362,17 +362,17 @@ const errorEmbeds = () => {

 const helpMenuEmbeds = () => {
    //HELP MENU
-    embeds.add(new api.ODEmbed("openticket:help-menu"))
-    embeds.get("openticket:help-menu").workers.add(
-        new api.ODWorker("openticket:help-menu",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:help-menu"))
+    embeds.get("opendiscord:help-menu").workers.add(
+        new api.ODWorker("opendiscord:help-menu",0,async (instance,params) => {
            const {mode,page} = params
            
            instance.setColor(generalConfig.data.mainColor)
            instance.setTitle(utilities.emojiTitle("ℹ️",lang.getTranslation("actions.titles.help")))
            instance.setDescription(lang.getTranslation("actions.descriptions.helpExplanation"))
-            instance.setThumbnail(openticket.client.client.user.displayAvatarURL())
+            instance.setThumbnail(opendiscord.client.client.user.displayAvatarURL())
            
-            const data = await openticket.helpmenu.render(mode)
+            const data = await opendiscord.helpmenu.render(mode)
            const currentData = data[page] ?? []
            instance.setFields(currentData)
        })
@@ -381,12 +381,12 @@ const helpMenuEmbeds = () => {

 const statsEmbeds = () => {
    //STATS GLOBAL
-    embeds.add(new api.ODEmbed("openticket:stats-global"))
-    embeds.get("openticket:stats-global").workers.add(
-        new api.ODWorker("openticket:stats-global",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:stats-global"))
+    embeds.get("opendiscord:stats-global").workers.add(
+        new api.ODWorker("opendiscord:stats-global",0,async (instance,params) => {
            const {guild,channel,user} = params
            
-            const scope = openticket.stats.get("openticket:global")
+            const scope = opendiscord.stats.get("opendiscord:global")
            if (!scope) return
            const data = await scope.render("GLOBAL",guild,channel,user)
            
@@ -394,9 +394,9 @@ const statsEmbeds = () => {
            instance.setTitle(scope.name)
            instance.setDescription(data)
            
-            if (openticket.permissions.hasPermissions("owner",await openticket.permissions.getPermissions(user,channel,guild))){
+            if (opendiscord.permissions.hasPermissions("owner",await opendiscord.permissions.getPermissions(user,channel,guild))){
                //show system data when owner or developer
-                const systemScope = openticket.stats.get("openticket:system")
+                const systemScope = opendiscord.stats.get("opendiscord:system")
                if (!systemScope) return
                const systemData = await systemScope.render("GLOBAL",guild,channel,user)
                instance.addFields({name:systemScope.name,value:systemData,inline:false})
@@ -405,13 +405,13 @@ const statsEmbeds = () => {
    )

    //STATS TICKET
-    embeds.add(new api.ODEmbed("openticket:stats-ticket"))
-    embeds.get("openticket:stats-ticket").workers.add(
-        new api.ODWorker("openticket:stats-ticket",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:stats-ticket"))
+    embeds.get("opendiscord:stats-ticket").workers.add(
+        new api.ODWorker("opendiscord:stats-ticket",0,async (instance,params) => {
            const {guild,channel,user,scopeData} = params
            
-            const scope = openticket.stats.get("openticket:ticket")
-            const participantsScope = openticket.stats.get("openticket:participants")
+            const scope = opendiscord.stats.get("opendiscord:ticket")
+            const participantsScope = opendiscord.stats.get("opendiscord:participants")
            if (!scope || !participantsScope) return
            const data = await scope.render(scopeData.id.value,guild,channel,user)
            const participantsData = await participantsScope.render(scopeData.id.value,guild,channel,user)
@@ -424,12 +424,12 @@ const statsEmbeds = () => {
    )

    //STATS USER
-    embeds.add(new api.ODEmbed("openticket:stats-user"))
-    embeds.get("openticket:stats-user").workers.add([
-        new api.ODWorker("openticket:stats-user",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:stats-user"))
+    embeds.get("opendiscord:stats-user").workers.add([
+        new api.ODWorker("opendiscord:stats-user",0,async (instance,params) => {
            const {guild,channel,user,scopeData} = params
            
-            const scope = openticket.stats.get("openticket:user")
+            const scope = opendiscord.stats.get("opendiscord:user")
            if (!scope) return
            const data = await scope.render(scopeData.id,guild,channel,user)
            
@@ -438,9 +438,9 @@ const statsEmbeds = () => {
            instance.setDescription(data)
            instance.setThumbnail(scopeData.displayAvatarURL())
        }),
-        new api.ODWorker("openticket:easter-egg",-1,async (instance,params) => {
-            if (!openticket.flags.exists("openticket:no-easter")) return
-            const easterFlag = openticket.flags.get("openticket:no-easter")
+        new api.ODWorker("opendiscord:easter-egg",-1,async (instance,params) => {
+            if (!opendiscord.flags.exists("opendiscord:no-easter")) return
+            const easterFlag = opendiscord.flags.get("opendiscord:no-easter")
            if (!easterFlag.value){
                //🥚 add easter egg 🥚
                const {user} = params
@@ -449,14 +449,14 @@ const statsEmbeds = () => {
                }else if (utilities.easterEggs.translators.includes(user.id)){
                    instance.setFooter("💬 Open Ticket Translator")
                }
-            }            
+            }
        })
    ])

    //STATS RESET
-    embeds.add(new api.ODEmbed("openticket:stats-reset"))
-    embeds.get("openticket:stats-reset").workers.add(
-        new api.ODWorker("openticket:stats-reset",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:stats-reset"))
+    embeds.get("opendiscord:stats-reset").workers.add(
+        new api.ODWorker("opendiscord:stats-reset",0,async (instance,params) => {
            const {user,reason} = params
            
            instance.setColor(generalConfig.data.mainColor)
@@ -468,9 +468,9 @@ const statsEmbeds = () => {
    )

    //STATS TICKET UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:stats-ticket-unknown"))
-    embeds.get("openticket:stats-ticket-unknown").workers.add(
-        new api.ODWorker("openticket:stats-ticket-unknown",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:stats-ticket-unknown"))
+    embeds.get("opendiscord:stats-ticket-unknown").workers.add(
+        new api.ODWorker("opendiscord:stats-ticket-unknown",0,async (instance,params) => {
            const {user,id} = params
            
            instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -483,12 +483,12 @@ const statsEmbeds = () => {

 const panelEmbeds = () => {
    //PANEL
-    embeds.add(new api.ODEmbed("openticket:panel"))
-    embeds.get("openticket:panel").workers.add(
-        new api.ODWorker("openticket:panel",0,async (instance,params) => {
+    embeds.add(new api.ODEmbed("opendiscord:panel"))
+    embeds.get("opendiscord:panel").workers.add(
+        new api.ODWorker("opendiscord:panel",0,async (instance,params) => {
            const {panel} = params
-            if (!panel.exists("openticket:embed")) return
-            const embedOptions = panel.get("openticket:embed").value
+            if (!panel.exists("opendiscord:embed")) return
+            const embedOptions = panel.get("opendiscord:embed").value
            
            instance.setColor(embedOptions.customColor ? embedOptions.customColor : generalConfig.data.mainColor)
            instance.setTitle(embedOptions.title)
@@ -498,7 +498,7 @@ const panelEmbeds = () => {
            if (embedOptions.footer) instance.setFooter(embedOptions.footer)
            if (embedOptions.timestamp) instance.setTimestamp(new Date())
            
-            if (panel.get("openticket:describe-options-in-embed-description").value){
+            if (panel.get("opendiscord:describe-options-in-embed-description").value){
                //describe options in description
                const text = (await import("../data/openticket/panelLoader.js")).describePanelOptions("text",panel)
                instance.setDescription(embedOptions.description+"\n\n"+text)
@@ -506,11 +506,11 @@ const panelEmbeds = () => {
                instance.setDescription(embedOptions.description)
            }

-            if (panel.get("openticket:enable-max-tickets-warning-embed").value && generalConfig.data.system.limits.enabled){
+            if (panel.get("opendiscord:enable-max-tickets-warning-embed").value && generalConfig.data.system.limits.enabled){
                instance.setDescription(instance.data.description+"\n\n*"+lang.getTranslationWithParams("actions.descriptions.ticketMessageLimit",[generalConfig.data.system.limits.userMaximum.toString()])+"*")
            }

-            if (panel.get("openticket:describe-options-in-embed-fields").value){
+            if (panel.get("opendiscord:describe-options-in-embed-fields").value){
                //describe options in fields
                const fields = (await import("../data/openticket/panelLoader.js")).describePanelOptions("fields",panel)
                instance.setFields(fields)
@@ -523,9 +523,9 @@ const panelEmbeds = () => {

 const ticketEmbeds = () => {
    //TICKET CREATED
-    embeds.add(new api.ODEmbed("openticket:ticket-created"))
-    embeds.get("openticket:ticket-created").workers.add(
-        new api.ODWorker("openticket:ticket-created",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:ticket-created"))
+    embeds.get("opendiscord:ticket-created").workers.add(
+        new api.ODWorker("opendiscord:ticket-created",0,async (instance,params,source) => {
            const {user} = params

            instance.setColor(generalConfig.data.mainColor)
@@ -537,11 +537,11 @@ const ticketEmbeds = () => {
    )

    //TICKET CREATED DM
-    embeds.add(new api.ODEmbed("openticket:ticket-created-dm"))
-    embeds.get("openticket:ticket-created-dm").workers.add(
-        new api.ODWorker("openticket:ticket-created-dm",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:ticket-created-dm"))
+    embeds.get("opendiscord:ticket-created-dm").workers.add(
+        new api.ODWorker("opendiscord:ticket-created-dm",0,async (instance,params,source) => {
            const {user,ticket} = params
-            const embedOptions = ticket.option.get("openticket:dm-message-embed").value
+            const embedOptions = ticket.option.get("opendiscord:dm-message-embed").value
            
            instance.setColor(embedOptions.customColor ? (embedOptions.customColor as discord.ColorResolvable) : generalConfig.data.mainColor)
            instance.setTitle(embedOptions.title)
@@ -551,19 +551,19 @@ const ticketEmbeds = () => {
            if (embedOptions.description) instance.setDescription(embedOptions.description)
            if (embedOptions.fields) instance.setFields(embedOptions.fields)
            
-            if (ticket.get("openticket:closed").value && ticket.get("openticket:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.option.get("openticket:autodelete-days").value.toString()]))
-            else if (!ticket.get("openticket:closed").value && ticket.get("openticket:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.option.get("openticket:autoclose-hours").value.toString()]))       
+            if (ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.option.get("opendiscord:autodelete-days").value.toString()]))
+            else if (!ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.option.get("opendiscord:autoclose-hours").value.toString()]))       
        })
    )

    //TICKET CREATED LOGS
-    embeds.add(new api.ODEmbed("openticket:ticket-created-logs"))
-    embeds.get("openticket:ticket-created-logs").workers.add(
-        new api.ODWorker("openticket:ticket-created-logs",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:ticket-created-logs"))
+    embeds.get("opendiscord:ticket-created-logs").workers.add(
+        new api.ODWorker("opendiscord:ticket-created-logs",0,async (instance,params,source) => {
            const {user,ticket} = params
            
            const method = (source == "panel-button" || source == "panel-dropdown") ? lang.getTranslation("params.uppercase.panel") : (source == "slash" || source == "text") ? lang.getTranslation("params.uppercase.command") : lang.getTranslation("params.uppercase.system")
-            const blacklisted = openticket.blacklist.exists(user.id) ? lang.getTranslation("params.uppercase.true") : lang.getTranslation("params.uppercase.false")
+            const blacklisted = opendiscord.blacklist.exists(user.id) ? lang.getTranslation("params.uppercase.true") : lang.getTranslation("params.uppercase.false")

            instance.setColor(generalConfig.data.mainColor)
            instance.setTitle(utilities.emojiTitle("🎫",lang.getTranslation("actions.titles.created")))
@@ -572,7 +572,7 @@ const ticketEmbeds = () => {
            instance.setTimestamp(new Date())
            instance.setDescription(lang.getTranslationWithParams("actions.logs.createLog",[discord.userMention(user.id)]))
            instance.addFields(
-                {name:lang.getTranslation("params.uppercase.type")+":",value:"```"+ticket.option.get("openticket:name").value+"```",inline:false},
+                {name:lang.getTranslation("params.uppercase.type")+":",value:"```"+ticket.option.get("opendiscord:name").value+"```",inline:false},
                {name:lang.getTranslation("params.uppercase.method")+":",value:"```"+method+"```",inline:true},
                {name:lang.getTranslation("params.uppercase.blacklisted")+":",value:"```"+blacklisted+"```", inline:true}
            )
@@ -580,11 +580,11 @@ const ticketEmbeds = () => {
    )

    //TICKET MESSAGE
-    embeds.add(new api.ODEmbed("openticket:ticket-message"))
-    embeds.get("openticket:ticket-message").workers.add(
-        new api.ODWorker("openticket:ticket-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:ticket-message"))
+    embeds.get("opendiscord:ticket-message").workers.add(
+        new api.ODWorker("opendiscord:ticket-message",0,async (instance,params,source) => {
            const {user,ticket} = params
-            const embedOptions = ticket.option.get("openticket:ticket-message-embed").value
+            const embedOptions = ticket.option.get("opendiscord:ticket-message-embed").value
            
            instance.setColor(embedOptions.customColor ? embedOptions.customColor : generalConfig.data.mainColor)
            if (embedOptions.title) instance.setTitle(embedOptions.title)
@@ -593,8 +593,8 @@ const ticketEmbeds = () => {
            if (embedOptions.timestamp) instance.setTimestamp(new Date())
            if (embedOptions.description) instance.setDescription(embedOptions.description)
            
-            if (ticket.option.get("openticket:questions").value.length > 0){
-                const answers = ticket.get("openticket:answers").value
+            if (ticket.option.get("opendiscord:questions").value.length > 0){
+                const answers = ticket.get("opendiscord:answers").value
                answers.forEach((answer) => {
                    if (!answer.value || answer.value.length == 0) return
                    if (generalConfig.data.system.questionFieldsInCodeBlock) instance.addFields({name:answer.name,value:"```"+answer.value+"```",inline:false})
@@ -604,11 +604,11 @@ const ticketEmbeds = () => {
                instance.setFields(embedOptions.fields)
            }

-            if (ticket.get("openticket:closed").value && ticket.get("openticket:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.option.get("openticket:autodelete-days").value.toString()]))
-            else if (!ticket.get("openticket:closed").value && ticket.get("openticket:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.option.get("openticket:autoclose-hours").value.toString()]))
+            if (ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.get("opendiscord:autodelete-days").value.toString()]))
+            else if (!ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.get("opendiscord:autoclose-hours").value.toString()]))
            
-            if (ticket.get("openticket:claimed").value){
-                const claimUser = await openticket.tickets.getTicketUser(ticket,"claimer")
+            if (ticket.get("opendiscord:claimed").value){
+                const claimUser = await opendiscord.tickets.getTicketUser(ticket,"claimer")
                if (!claimUser) return
                instance.setAuthor(lang.getTranslationWithParams("params.uppercase.claimedBy",[claimUser.displayName]),claimUser.displayAvatarURL())
            }
@@ -616,9 +616,9 @@ const ticketEmbeds = () => {
    )

    //TICKET CLOSED
-    embeds.add(new api.ODEmbed("openticket:close-message"))
-    embeds.get("openticket:close-message").workers.add(
-        new api.ODWorker("openticket:close-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:close-message"))
+    embeds.get("opendiscord:close-message").workers.add(
+        new api.ODWorker("opendiscord:close-message",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -630,9 +630,9 @@ const ticketEmbeds = () => {
    )

    //TICKET REOPENED
-    embeds.add(new api.ODEmbed("openticket:reopen-message"))
-    embeds.get("openticket:reopen-message").workers.add(
-        new api.ODWorker("openticket:reopen-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:reopen-message"))
+    embeds.get("opendiscord:reopen-message").workers.add(
+        new api.ODWorker("opendiscord:reopen-message",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -644,9 +644,9 @@ const ticketEmbeds = () => {
    )

    //TICKET DELETED
-    embeds.add(new api.ODEmbed("openticket:delete-message"))
-    embeds.get("openticket:delete-message").workers.add(
-        new api.ODWorker("openticket:delete-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:delete-message"))
+    embeds.get("opendiscord:delete-message").workers.add(
+        new api.ODWorker("opendiscord:delete-message",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -658,9 +658,9 @@ const ticketEmbeds = () => {
    )

    //TICKET CLAIMED
-    embeds.add(new api.ODEmbed("openticket:claim-message"))
-    embeds.get("openticket:claim-message").workers.add(
-        new api.ODWorker("openticket:claim-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:claim-message"))
+    embeds.get("opendiscord:claim-message").workers.add(
+        new api.ODWorker("opendiscord:claim-message",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -672,9 +672,9 @@ const ticketEmbeds = () => {
    )

    //TICKET UNCLAIMED
-    embeds.add(new api.ODEmbed("openticket:unclaim-message"))
-    embeds.get("openticket:unclaim-message").workers.add(
-        new api.ODWorker("openticket:unclaim-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:unclaim-message"))
+    embeds.get("opendiscord:unclaim-message").workers.add(
+        new api.ODWorker("opendiscord:unclaim-message",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -686,9 +686,9 @@ const ticketEmbeds = () => {
    )

    //TICKET PINNED
-    embeds.add(new api.ODEmbed("openticket:pin-message"))
-    embeds.get("openticket:pin-message").workers.add(
-        new api.ODWorker("openticket:pin-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:pin-message"))
+    embeds.get("opendiscord:pin-message").workers.add(
+        new api.ODWorker("opendiscord:pin-message",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -700,9 +700,9 @@ const ticketEmbeds = () => {
    )

    //TICKET UNPINNED
-    embeds.add(new api.ODEmbed("openticket:unpin-message"))
-    embeds.get("openticket:unpin-message").workers.add(
-        new api.ODWorker("openticket:unpin-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:unpin-message"))
+    embeds.get("opendiscord:unpin-message").workers.add(
+        new api.ODWorker("opendiscord:unpin-message",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -714,9 +714,9 @@ const ticketEmbeds = () => {
    )

    //TICKET RENAMED
-    embeds.add(new api.ODEmbed("openticket:rename-message"))
-    embeds.get("openticket:rename-message").workers.add(
-        new api.ODWorker("openticket:rename-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:rename-message"))
+    embeds.get("opendiscord:rename-message").workers.add(
+        new api.ODWorker("opendiscord:rename-message",0,async (instance,params,source) => {
            const {user,ticket,reason,data} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -728,23 +728,23 @@ const ticketEmbeds = () => {
    )

    //TICKET MOVED
-    embeds.add(new api.ODEmbed("openticket:move-message"))
-    embeds.get("openticket:move-message").workers.add(
-        new api.ODWorker("openticket:move-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:move-message"))
+    embeds.get("opendiscord:move-message").workers.add(
+        new api.ODWorker("opendiscord:move-message",0,async (instance,params,source) => {
            const {user,ticket,reason,data} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
            instance.setColor(generalConfig.data.mainColor)
            instance.setTitle(utilities.emojiTitle("🔀",lang.getTranslation("actions.titles.move")))
-            instance.setDescription(lang.getTranslationWithParams("actions.descriptions.move",["`"+data.get("openticket:name").value+"`"]))
+            instance.setDescription(lang.getTranslationWithParams("actions.descriptions.move",["`"+data.get("opendiscord:name").value+"`"]))
            if (reason) instance.addFields({name:lang.getTranslation("params.uppercase.reason")+":",value:"```"+reason+"```"})
        })
    )

    //TICKET USER ADDED
-    embeds.add(new api.ODEmbed("openticket:add-message"))
-    embeds.get("openticket:add-message").workers.add(
-        new api.ODWorker("openticket:add-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:add-message"))
+    embeds.get("opendiscord:add-message").workers.add(
+        new api.ODWorker("opendiscord:add-message",0,async (instance,params,source) => {
            const {user,ticket,reason,data} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -756,9 +756,9 @@ const ticketEmbeds = () => {
    )

    //TICKET USER REMOVED
-    embeds.add(new api.ODEmbed("openticket:remove-message"))
-    embeds.get("openticket:remove-message").workers.add(
-        new api.ODWorker("openticket:remove-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:remove-message"))
+    embeds.get("opendiscord:remove-message").workers.add(
+        new api.ODWorker("opendiscord:remove-message",0,async (instance,params,source) => {
            const {user,ticket,reason,data} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -770,11 +770,11 @@ const ticketEmbeds = () => {
    )
    
    //TICKET ACTION DM
-    embeds.add(new api.ODEmbed("openticket:ticket-action-dm"))
-    embeds.get("openticket:ticket-action-dm").workers.add(
-        new api.ODWorker("openticket:ticket-action-dm",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:ticket-action-dm"))
+    embeds.get("opendiscord:ticket-action-dm").workers.add(
+        new api.ODWorker("opendiscord:ticket-action-dm",0,async (instance,params,source) => {
            const {user,mode,ticket,reason,additionalData} = params
-            const channel = await openticket.tickets.getTicketChannel(ticket)
+            const channel = await opendiscord.tickets.getTicketChannel(ticket)
            
            instance.setColor(generalConfig.data.mainColor)
            instance.setTimestamp(new Date())
@@ -807,7 +807,7 @@ const ticketEmbeds = () => {
                instance.setDescription(lang.getTranslationWithParams("actions.logs.renameDm",["`#"+(typeof additionalData == "string" ? additionalData : "<unknown>")+"`"]))
            }else if (mode == "move"){
                instance.setTitle(utilities.emojiTitle("🔀",lang.getTranslation("actions.titles.move")))
-                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveDm",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("openticket:name").value : "<unknown>")+"`"]))
+                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveDm",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("opendiscord:name").value : "<unknown>")+"`"]))
            }else if (mode == "add"){
                instance.setTitle(utilities.emojiTitle("👤",lang.getTranslation("actions.titles.add")))
                instance.setDescription(lang.getTranslationWithParams("actions.logs.addDm",[(additionalData instanceof discord.User ? discord.userMention(additionalData.id) : "<unknown>")]))
@@ -819,11 +819,11 @@ const ticketEmbeds = () => {
    )

    //TICKET ACTION LOGS
-    embeds.add(new api.ODEmbed("openticket:ticket-action-logs"))
-    embeds.get("openticket:ticket-action-logs").workers.add(
-        new api.ODWorker("openticket:ticket-action-logs",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:ticket-action-logs"))
+    embeds.get("opendiscord:ticket-action-logs").workers.add(
+        new api.ODWorker("opendiscord:ticket-action-logs",0,async (instance,params,source) => {
            const {user,mode,ticket,reason,additionalData} = params
-            const channel = await openticket.tickets.getTicketChannel(ticket)
+            const channel = await opendiscord.tickets.getTicketChannel(ticket)

            instance.setColor(generalConfig.data.mainColor)
            instance.setThumbnail(user.displayAvatarURL())
@@ -832,7 +832,7 @@ const ticketEmbeds = () => {
            instance.addFields(
                {name:lang.getTranslation("params.uppercase.ticket")+":",value:"```#"+(channel ? channel.name : "<unknown>")+"```",inline:false},
                //TODO TRANSLATION!!!
-                {name:"Option"+":",value:"```"+(ticket.option.get("openticket:name").value)+"```",inline:false},
+                {name:"Option"+":",value:"```"+(ticket.option.get("opendiscord:name").value)+"```",inline:false},
            )
            if (reason) instance.addFields({name:lang.getTranslation("params.uppercase.reason")+":",value:"```"+reason+"```",inline:false})

@@ -862,7 +862,7 @@ const ticketEmbeds = () => {
                instance.setDescription(lang.getTranslationWithParams("actions.logs.renameLog",["`#"+(typeof additionalData == "string" ? additionalData : "<unknown>")+"`",discord.userMention(user.id)]))
            }else if (mode == "move"){
                instance.setTitle(utilities.emojiTitle("🔀",lang.getTranslation("actions.titles.move")))
-                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveLog",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("openticket:name").value : "<unknown>")+"`",discord.userMention(user.id)]))
+                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveLog",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("opendiscord:name").value : "<unknown>")+"`",discord.userMention(user.id)]))
            }else if (mode == "add"){
                instance.setTitle(utilities.emojiTitle("👤",lang.getTranslation("actions.titles.add")))
                instance.setDescription(lang.getTranslationWithParams("actions.logs.addLog",[(additionalData instanceof discord.User ? discord.userMention(additionalData.id) : "<unknown>"),discord.userMention(user.id)]))
@@ -876,13 +876,13 @@ const ticketEmbeds = () => {

 const blacklistEmbeds = () => {
    //BLACKLIST VIEW
-    embeds.add(new api.ODEmbed("openticket:blacklist-view"))
-    embeds.get("openticket:blacklist-view").workers.add(
-        new api.ODWorker("openticket:blacklist-view",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-view"))
+    embeds.get("opendiscord:blacklist-view").workers.add(
+        new api.ODWorker("opendiscord:blacklist-view",0,async (instance,params,source) => {
            const {user} = params

            const renderedUsers: string[] = []
-            await openticket.blacklist.loopAll((blacklist,id) => {renderedUsers.push(discord.userMention(id.value)+" - "+(blacklist.reason ? blacklist.reason : "/"))})
+            await opendiscord.blacklist.loopAll((blacklist,id) => {renderedUsers.push(discord.userMention(id.value)+" - "+(blacklist.reason ? blacklist.reason : "/"))})

            instance.setAuthor(user.displayName,user.displayAvatarURL())
            instance.setColor(generalConfig.data.mainColor)
@@ -896,11 +896,11 @@ const blacklistEmbeds = () => {
        })
    )
    //BLACKLIST GET
-    embeds.add(new api.ODEmbed("openticket:blacklist-get"))
-    embeds.get("openticket:blacklist-get").workers.add(
-        new api.ODWorker("openticket:blacklist-get",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-get"))
+    embeds.get("opendiscord:blacklist-get").workers.add(
+        new api.ODWorker("opendiscord:blacklist-get",0,async (instance,params,source) => {
            const {user,data} = params
-            const blacklist = openticket.blacklist.get(data.id)
+            const blacklist = opendiscord.blacklist.get(data.id)

            instance.setAuthor(user.displayName,user.displayAvatarURL())
            instance.setColor(generalConfig.data.mainColor)
@@ -915,9 +915,9 @@ const blacklistEmbeds = () => {
    )

    //BLACKLIST ADD
-    embeds.add(new api.ODEmbed("openticket:blacklist-add"))
-    embeds.get("openticket:blacklist-add").workers.add(
-        new api.ODWorker("openticket:blacklist-add",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-add"))
+    embeds.get("opendiscord:blacklist-add").workers.add(
+        new api.ODWorker("opendiscord:blacklist-add",0,async (instance,params,source) => {
            const {user,data,reason} = params
            
            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -929,9 +929,9 @@ const blacklistEmbeds = () => {
    )

    //BLACKLIST REMOVE
-    embeds.add(new api.ODEmbed("openticket:blacklist-remove"))
-    embeds.get("openticket:blacklist-remove").workers.add(
-        new api.ODWorker("openticket:blacklist-remove",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-remove"))
+    embeds.get("opendiscord:blacklist-remove").workers.add(
+        new api.ODWorker("opendiscord:blacklist-remove",0,async (instance,params,source) => {
            const {user,data,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -943,9 +943,9 @@ const blacklistEmbeds = () => {
    )

    //BLACKLIST DM
-    embeds.add(new api.ODEmbed("openticket:blacklist-dm"))
-    embeds.get("openticket:blacklist-dm").workers.add(
-        new api.ODWorker("openticket:blacklist-dm",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-dm"))
+    embeds.get("opendiscord:blacklist-dm").workers.add(
+        new api.ODWorker("opendiscord:blacklist-dm",0,async (instance,params,source) => {
            const {user,mode,data,reason} = params
            
            const title = (mode == "add") ? lang.getTranslation("actions.titles.blacklistAddDm") : lang.getTranslation("actions.titles.blacklistRemoveDm")
@@ -960,9 +960,9 @@ const blacklistEmbeds = () => {
    )

    //BLACKLIST LOGS
-    embeds.add(new api.ODEmbed("openticket:blacklist-logs"))
-    embeds.get("openticket:blacklist-logs").workers.add(
-        new api.ODWorker("openticket:blacklist-logs",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-logs"))
+    embeds.get("opendiscord:blacklist-logs").workers.add(
+        new api.ODWorker("opendiscord:blacklist-logs",0,async (instance,params,source) => {
            const {user,mode,data,reason} = params
            
            const title = (mode == "add") ? lang.getTranslation("actions.titles.blacklistAdd") : lang.getTranslation("actions.titles.blacklistRemove")
@@ -981,18 +981,18 @@ const blacklistEmbeds = () => {

 const transcriptEmbeds = () => {
    //TRANSCRIPT TEXT READY
-    embeds.add(new api.ODEmbed("openticket:transcript-text-ready"))
-    embeds.get("openticket:transcript-text-ready").workers.add(
-        new api.ODWorker("openticket:transcript-text-ready",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:transcript-text-ready"))
+    embeds.get("opendiscord:transcript-text-ready").workers.add(
+        new api.ODWorker("opendiscord:transcript-text-ready",0,async (instance,params,source) => {
            const {guild,channel,user,ticket,compiler} = params
-            const transcriptConfig = openticket.configs.get("openticket:transcripts")
+            const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")
            
            instance.setColor(transcriptConfig.data.embedSettings.customColor ? transcriptConfig.data.embedSettings.customColor : generalConfig.data.mainColor)
            instance.setTitle(utilities.emojiTitle("📄",lang.getTranslation("transcripts.success.ready")))
            instance.setTimestamp(new Date())
            instance.addFields({name:lang.getTranslation("params.uppercase.ticket")+":",value:"#"+channel.name,inline:false})

-            const creatorId = ticket.get("openticket:opened-by").value
+            const creatorId = ticket.get("opendiscord:opened-by").value
            if (creatorId){
                try{
                    const creator = await channel.client.users.fetch(creatorId)
@@ -1011,11 +1011,11 @@ const transcriptEmbeds = () => {
    )

    //TRANSCRIPT HTML READY
-    embeds.add(new api.ODEmbed("openticket:transcript-html-ready"))
-    embeds.get("openticket:transcript-html-ready").workers.add(
-        new api.ODWorker("openticket:transcript-html-ready",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:transcript-html-ready"))
+    embeds.get("opendiscord:transcript-html-ready").workers.add(
+        new api.ODWorker("opendiscord:transcript-html-ready",0,async (instance,params,source) => {
            const {guild,channel,user,ticket,compiler,result} = params
-            const transcriptConfig = openticket.configs.get("openticket:transcripts")
+            const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")
            
            instance.setColor(transcriptConfig.data.embedSettings.customColor ? transcriptConfig.data.embedSettings.customColor : generalConfig.data.mainColor)
            instance.setTitle(utilities.emojiTitle("📄",lang.getTranslation("transcripts.success.ready")))
@@ -1023,7 +1023,7 @@ const transcriptEmbeds = () => {
            instance.addFields({name:lang.getTranslation("params.uppercase.ticket")+":",value:"#"+channel.name,inline:false})
            if (result.data) instance.setUrl(result.data.url)

-            const creatorId = ticket.get("openticket:opened-by").value
+            const creatorId = ticket.get("opendiscord:opened-by").value
            if (creatorId){
                try{
                    const creator = await channel.client.users.fetch(creatorId)
@@ -1042,9 +1042,9 @@ const transcriptEmbeds = () => {
    )

    //TRANSCRIPT HTML PROGRESS
-    embeds.add(new api.ODEmbed("openticket:transcript-html-progress"))
-    embeds.get("openticket:transcript-html-progress").workers.add(
-        new api.ODWorker("openticket:transcript-html-progress",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:transcript-html-progress"))
+    embeds.get("opendiscord:transcript-html-progress").workers.add(
+        new api.ODWorker("opendiscord:transcript-html-progress",0,async (instance,params,source) => {
            const {guild,channel,user,ticket,compiler,remaining} = params
            
            const remainingDate = new Date(new Date().getTime()+remaining)
@@ -1056,7 +1056,7 @@ const transcriptEmbeds = () => {
            instance.addFields({name:lang.getTranslation("params.uppercase.remaining")+":",value:discord.time(remainingDate,"R"),inline:false})
            instance.addFields({name:lang.getTranslation("params.uppercase.ticket")+":",value:"#"+channel.name,inline:false})

-            const creatorId = ticket.get("openticket:opened-by").value
+            const creatorId = ticket.get("opendiscord:opened-by").value
            if (creatorId){
                try{
                    const creator = await channel.client.users.fetch(creatorId)
@@ -1068,9 +1068,9 @@ const transcriptEmbeds = () => {
    )

    //TRANSCRIPT ERROR
-    embeds.add(new api.ODEmbed("openticket:transcript-error"))
-    embeds.get("openticket:transcript-error").workers.add(
-        new api.ODWorker("openticket:transcript-error",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:transcript-error"))
+    embeds.get("opendiscord:transcript-error").workers.add(
+        new api.ODWorker("opendiscord:transcript-error",0,async (instance,params,source) => {
            const {guild,channel,user,ticket,compiler,reason} = params
            
            instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -1085,9 +1085,9 @@ const transcriptEmbeds = () => {

 const roleEmbeds = () => {
    //REACTION ROLE
-    embeds.add(new api.ODEmbed("openticket:reaction-role"))
-    embeds.get("openticket:reaction-role").workers.add(
-        new api.ODWorker("openticket:reaction-role",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:reaction-role"))
+    embeds.get("opendiscord:reaction-role").workers.add(
+        new api.ODWorker("opendiscord:reaction-role",0,async (instance,params,source) => {
            const {guild,user,role,result} = params

            instance.setColor(generalConfig.data.mainColor)
@@ -1111,9 +1111,9 @@ const roleEmbeds = () => {

 const clearEmbeds = () => {
    //CLEAR VERIFY MESSAGE
-    embeds.add(new api.ODEmbed("openticket:clear-verify-message"))
-    embeds.get("openticket:clear-verify-message").workers.add(
-        new api.ODWorker("openticket:clear-verify-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:clear-verify-message"))
+    embeds.get("opendiscord:clear-verify-message").workers.add(
+        new api.ODWorker("opendiscord:clear-verify-message",0,async (instance,params,source) => {
            const {guild,channel,user,filter,list} = params
            
            instance.setColor(generalConfig.data.mainColor)
@@ -1129,9 +1129,9 @@ const clearEmbeds = () => {
    )

    //CLEAR MESSAGE
-    embeds.add(new api.ODEmbed("openticket:clear-message"))
-    embeds.get("openticket:clear-message").workers.add(
-        new api.ODWorker("openticket:clear-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:clear-message"))
+    embeds.get("opendiscord:clear-message").workers.add(
+        new api.ODWorker("opendiscord:clear-message",0,async (instance,params,source) => {
            const {guild,channel,user,filter,list} = params
            
            instance.setColor(generalConfig.data.mainColor)
@@ -1146,9 +1146,9 @@ const clearEmbeds = () => {
    )

    //CLEAR LOGS
-    embeds.add(new api.ODEmbed("openticket:clear-logs"))
-    embeds.get("openticket:clear-logs").workers.add(
-        new api.ODWorker("openticket:clear-logs",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:clear-logs"))
+    embeds.get("opendiscord:clear-logs").workers.add(
+        new api.ODWorker("opendiscord:clear-logs",0,async (instance,params,source) => {
            const {guild,channel,user,filter,list} = params
            
            instance.setColor(generalConfig.data.mainColor)
@@ -1166,11 +1166,11 @@ const clearEmbeds = () => {

 const autoEmbeds = () => {
    //AUTOCLOSE MESSAGE
-    embeds.add(new api.ODEmbed("openticket:autoclose-message"))
-    embeds.get("openticket:autoclose-message").workers.add(
-        new api.ODWorker("openticket:autoclose-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:autoclose-message"))
+    embeds.get("opendiscord:autoclose-message").workers.add(
+        new api.ODWorker("opendiscord:autoclose-message",0,async (instance,params,source) => {
            const {user,ticket} = params
-            const hours: number = ticket.get("openticket:autoclose-hours").value
+            const hours: number = ticket.get("opendiscord:autoclose-hours").value
            const description = (source == "leave") ? lang.getTranslation("actions.descriptions.autocloseLeave") : lang.getTranslationWithParams("actions.descriptions.autocloseTimeout",[hours.toString()])

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1182,11 +1182,11 @@ const autoEmbeds = () => {
    )

    //AUTODELETE MESSAGE
-    embeds.add(new api.ODEmbed("openticket:autodelete-message"))
-    embeds.get("openticket:autodelete-message").workers.add(
-        new api.ODWorker("openticket:autodelete-message",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:autodelete-message"))
+    embeds.get("opendiscord:autodelete-message").workers.add(
+        new api.ODWorker("opendiscord:autodelete-message",0,async (instance,params,source) => {
            const {user,ticket} = params
-            const days: number = ticket.get("openticket:autodelete-days").value
+            const days: number = ticket.get("opendiscord:autodelete-days").value
            const description = (source == "leave") ? lang.getTranslation("actions.descriptions.autodeleteLeave") : lang.getTranslationWithParams("actions.descriptions.autodeleteTimeout",[days.toString()])

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1198,9 +1198,9 @@ const autoEmbeds = () => {
    )

    //AUTOCLOSE ENABLE
-    embeds.add(new api.ODEmbed("openticket:autoclose-enable"))
-    embeds.get("openticket:autoclose-enable").workers.add(
-        new api.ODWorker("openticket:autoclose-enable",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:autoclose-enable"))
+    embeds.get("opendiscord:autoclose-enable").workers.add(
+        new api.ODWorker("opendiscord:autoclose-enable",0,async (instance,params,source) => {
            const {user,ticket,reason,time} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1212,9 +1212,9 @@ const autoEmbeds = () => {
    )

    //AUTODELETE ENABLE
-    embeds.add(new api.ODEmbed("openticket:autodelete-enable"))
-    embeds.get("openticket:autodelete-enable").workers.add(
-        new api.ODWorker("openticket:autodelete-enable",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:autodelete-enable"))
+    embeds.get("opendiscord:autodelete-enable").workers.add(
+        new api.ODWorker("opendiscord:autodelete-enable",0,async (instance,params,source) => {
            const {user,ticket,reason,time} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1226,9 +1226,9 @@ const autoEmbeds = () => {
    )

    //AUTOCLOSE DISABLE
-    embeds.add(new api.ODEmbed("openticket:autoclose-disable"))
-    embeds.get("openticket:autoclose-disable").workers.add(
-        new api.ODWorker("openticket:autoclose-disable",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:autoclose-disable"))
+    embeds.get("opendiscord:autoclose-disable").workers.add(
+        new api.ODWorker("opendiscord:autoclose-disable",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1240,9 +1240,9 @@ const autoEmbeds = () => {
    )

    //AUTODELETE DISABLE
-    embeds.add(new api.ODEmbed("openticket:autodelete-disable"))
-    embeds.get("openticket:autodelete-disable").workers.add(
-        new api.ODWorker("openticket:autodelete-disable",0,async (instance,params,source) => {
+    embeds.add(new api.ODEmbed("opendiscord:autodelete-disable"))
+    embeds.get("opendiscord:autodelete-disable").workers.add(
+        new api.ODWorker("opendiscord:autodelete-disable",0,async (instance,params,source) => {
            const {user,ticket,reason} = params

            instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1,12 +1,12 @@
 ///////////////////////////////////////
 //FILE BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const files = openticket.builders.files
-const lang = openticket.languages
-const transcriptConfig = openticket.configs.get("openticket:transcripts")
+const files = opendiscord.builders.files
+const lang = opendiscord.languages
+const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")

 export const registerAllFiles = async () => {
    transcriptFiles()
@@ -15,16 +15,16 @@ export const registerAllFiles = async () => {

 const transcriptFiles = () => {
    //TEXT TRANSCRIPT
-    files.add(new api.ODFile("openticket:text-transcript"))
-    files.get("openticket:text-transcript").workers.add(
-        new api.ODWorker("openticket:text-transcript",0,async (instance,params,source) => {
+    files.add(new api.ODFile("opendiscord:text-transcript"))
+    files.get("opendiscord:text-transcript").workers.add(
+        new api.ODWorker("opendiscord:text-transcript",0,async (instance,params,source) => {
            const {guild,channel,user,ticket,compiler,result} = params
            
            const fileMode = transcriptConfig.data.textTranscriptStyle.fileMode
            const customName = transcriptConfig.data.textTranscriptStyle.customFileName

-            const creatorId = ticket.get("openticket:opened-by").value ?? "unknown-creator-id"
-            const creator = (await openticket.tickets.getTicketUser(ticket,"creator"))
+            const creatorId = ticket.get("opendiscord:opened-by").value ?? "unknown-creator-id"
+            const creator = (await opendiscord.tickets.getTicketUser(ticket,"creator"))

            if (fileMode == "custom") instance.setName(customName.split(".")[0]+".txt")
            else if (fileMode == "user-id") instance.setName(creatorId+".txt")
@@ -35,7 +35,7 @@ const transcriptFiles = () => {

            instance.setDescription(lang.getTranslation("transcripts.success.textFileDescription"))
            
-            if (compiler.id.value != "openticket:text-compiler" || !result.data || typeof result.data.contents != "string"){
+            if (compiler.id.value != "opendiscord:text-compiler" || !result.data || typeof result.data.contents != "string"){
                instance.setContents("<invalid-transcript-compiler>")
                return
            }
@@ -1,54 +1,54 @@
 ///////////////////////////////////////
 //MODAL BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const modals = openticket.builders.modals
-const lang = openticket.languages
+const modals = opendiscord.builders.modals
+const lang = opendiscord.languages

 export const registerAllModals = async () => {
    ticketModals()
 }
 const ticketModals = () => {
    //TICKET QUESTIONS
-    modals.add(new api.ODModal("openticket:ticket-questions"))
-    modals.get("openticket:ticket-questions").workers.add(
-        new api.ODWorker("openticket:ticket-questions",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:ticket-questions"))
+    modals.get("opendiscord:ticket-questions").workers.add(
+        new api.ODWorker("opendiscord:ticket-questions",0,async (instance,params,source) => {
            const {option} = params
            
            instance.setCustomId("od:ticket-questions_"+option.id.value+"_"+source)
-            instance.setTitle(option.exists("openticket:name") ? option.get("openticket:name").value : option.id.value)
-            const questionIds = option.get("openticket:questions").value
+            instance.setTitle(option.exists("opendiscord:name") ? option.get("opendiscord:name").value : option.id.value)
+            const questionIds = option.get("opendiscord:questions").value
            questionIds.forEach((id) => {
-                const question = openticket.questions.get(id)
+                const question = opendiscord.questions.get(id)
                if (!question) return
                if (question instanceof api.ODShortQuestion) instance.addQuestion({
                    customId:question.id.value,
-                    label:question.get("openticket:name").value,
+                    label:question.get("opendiscord:name").value,
                    style:"short",
-                    required:question.get("openticket:required").value,
-                    placeholder:(question.get("openticket:placeholder").value) ? question.get("openticket:placeholder").value : undefined,
-                    minLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-min").value : undefined,
-                    maxLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-max").value : undefined
+                    required:question.get("opendiscord:required").value,
+                    placeholder:(question.get("opendiscord:placeholder").value) ? question.get("opendiscord:placeholder").value : undefined,
+                    minLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-min").value : undefined,
+                    maxLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-max").value : undefined
                })
                else if (question instanceof api.ODParagraphQuestion) instance.addQuestion({
                    customId:question.id.value,
-                    label:question.get("openticket:name").value,
+                    label:question.get("opendiscord:name").value,
                    style:"paragraph",
-                    required:question.get("openticket:required").value,
-                    placeholder:(question.get("openticket:placeholder").value) ? question.get("openticket:placeholder").value : undefined,
-                    minLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-min").value : undefined,
-                    maxLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-max").value : undefined
+                    required:question.get("opendiscord:required").value,
+                    placeholder:(question.get("opendiscord:placeholder").value) ? question.get("opendiscord:placeholder").value : undefined,
+                    minLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-min").value : undefined,
+                    maxLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-max").value : undefined
                })
            })
        })
    )

    //CLOSE TICKET REASON
-    modals.add(new api.ODModal("openticket:close-ticket-reason"))
-    modals.get("openticket:close-ticket-reason").workers.add(
-        new api.ODWorker("openticket:close-ticket-reason",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:close-ticket-reason"))
+    modals.get("opendiscord:close-ticket-reason").workers.add(
+        new api.ODWorker("opendiscord:close-ticket-reason",0,async (instance,params,source) => {
            const {ticket} = params

            instance.setCustomId("od:close-ticket-reason_"+ticket.id.value+"_"+source)
@@ -64,9 +64,9 @@ const ticketModals = () => {
    )

    //REOPEN TICKET REASON
-    modals.add(new api.ODModal("openticket:reopen-ticket-reason"))
-    modals.get("openticket:reopen-ticket-reason").workers.add(
-        new api.ODWorker("openticket:reopen-ticket-reason",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:reopen-ticket-reason"))
+    modals.get("opendiscord:reopen-ticket-reason").workers.add(
+        new api.ODWorker("opendiscord:reopen-ticket-reason",0,async (instance,params,source) => {
            const {ticket} = params

            instance.setCustomId("od:reopen-ticket-reason_"+ticket.id.value+"_"+source)
@@ -82,9 +82,9 @@ const ticketModals = () => {
    )

    //DELETE TICKET REASON
-    modals.add(new api.ODModal("openticket:delete-ticket-reason"))
-    modals.get("openticket:delete-ticket-reason").workers.add(
-        new api.ODWorker("openticket:delete-ticket-reason",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:delete-ticket-reason"))
+    modals.get("opendiscord:delete-ticket-reason").workers.add(
+        new api.ODWorker("opendiscord:delete-ticket-reason",0,async (instance,params,source) => {
            const {ticket} = params

            instance.setCustomId("od:delete-ticket-reason_"+ticket.id.value+"_"+source)
@@ -100,9 +100,9 @@ const ticketModals = () => {
    )

    //CLAIM TICKET REASON
-    modals.add(new api.ODModal("openticket:claim-ticket-reason"))
-    modals.get("openticket:claim-ticket-reason").workers.add(
-        new api.ODWorker("openticket:claim-ticket-reason",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:claim-ticket-reason"))
+    modals.get("opendiscord:claim-ticket-reason").workers.add(
+        new api.ODWorker("opendiscord:claim-ticket-reason",0,async (instance,params,source) => {
            const {ticket} = params

            instance.setCustomId("od:claim-ticket-reason_"+ticket.id.value+"_"+source)
@@ -118,9 +118,9 @@ const ticketModals = () => {
    )

    //UNCLAIM TICKET REASON
-    modals.add(new api.ODModal("openticket:unclaim-ticket-reason"))
-    modals.get("openticket:unclaim-ticket-reason").workers.add(
-        new api.ODWorker("openticket:unclaim-ticket-reason",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:unclaim-ticket-reason"))
+    modals.get("opendiscord:unclaim-ticket-reason").workers.add(
+        new api.ODWorker("opendiscord:unclaim-ticket-reason",0,async (instance,params,source) => {
            const {ticket} = params

            instance.setCustomId("od:unclaim-ticket-reason_"+ticket.id.value+"_"+source)
@@ -136,9 +136,9 @@ const ticketModals = () => {
    )

    //PIN TICKET REASON
-    modals.add(new api.ODModal("openticket:pin-ticket-reason"))
-    modals.get("openticket:pin-ticket-reason").workers.add(
-        new api.ODWorker("openticket:pin-ticket-reason",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:pin-ticket-reason"))
+    modals.get("opendiscord:pin-ticket-reason").workers.add(
+        new api.ODWorker("opendiscord:pin-ticket-reason",0,async (instance,params,source) => {
            const {ticket} = params

            instance.setCustomId("od:pin-ticket-reason_"+ticket.id.value+"_"+source)
@@ -154,9 +154,9 @@ const ticketModals = () => {
    )

    //UNPIN TICKET REASON
-    modals.add(new api.ODModal("openticket:unpin-ticket-reason"))
-    modals.get("openticket:unpin-ticket-reason").workers.add(
-        new api.ODWorker("openticket:unpin-ticket-reason",0,async (instance,params,source) => {
+    modals.add(new api.ODModal("opendiscord:unpin-ticket-reason"))
+    modals.get("opendiscord:unpin-ticket-reason").workers.add(
+        new api.ODWorker("opendiscord:unpin-ticket-reason",0,async (instance,params,source) => {
            const {ticket} = params

            instance.setCustomId("od:unpin-ticket-reason_"+ticket.id.value+"_"+source)
@@ -1,62 +1,62 @@
 ///////////////////////////////////////
 //ADD COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //ADD COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:add",generalConfig.data.prefix,"add"))
-    openticket.responders.commands.get("openticket:add").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:add",generalConfig.data.prefix,"add"))
+    opendiscord.responders.commands.get("opendiscord:add").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.add

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:add",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:add",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -64,19 +64,19 @@ export const registerCommandResponders = async () => {
            const reason = instance.options.getString("reason",false)

            //return when user already added to ticket
-            const participants = await openticket.tickets.getAllTicketParticipants(ticket)
+            const participants = await opendiscord.tickets.getAllTicketParticipants(ticket)
            if (!participants || participants.find((p) => p.user.id == data.id)){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.add"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.add"),layout:"simple"}))
                return cancel()
            }

            //start adding user to ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:add-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:add-message").build(source,{guild,channel,user,ticket,reason,data}))
+            await opendiscord.actions.get("opendiscord:add-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:add-message").build(source,{guild,channel,user,ticket,reason,data}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'add' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'add' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,68 +1,68 @@
 ///////////////////////////////////////
 //AUTOCLOSE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //AUTOCLOSE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:autoclose",generalConfig.data.prefix,/^autoclose/))
-    openticket.responders.commands.get("openticket:autoclose").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:autoclose",generalConfig.data.prefix,/^autoclose/))
+    opendiscord.responders.commands.get("opendiscord:autoclose").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.autoclose
            
            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:autoclose",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:autoclose",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }
            //return when already closed
-            if (ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+            if (ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -71,38 +71,38 @@ export const registerCommandResponders = async () => {

            if (scope == "disable"){
                const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autoclose-enabled").value = false
-                ticket.get("openticket:autoclose-hours").value = 0
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autoclose-disable").build(source,{guild,channel,user,ticket,reason}))
+                ticket.get("opendiscord:autoclose-enabled").value = false
+                ticket.get("opendiscord:autoclose-hours").value = 0
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-disable").build(source,{guild,channel,user,ticket,reason}))
            
            }else if (scope == "enable"){
                const time = instance.options.getNumber("time",true)
                const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autoclose-enabled").value = true
-                ticket.get("openticket:autoclose-hours").value = time
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autoclose-enable").build(source,{guild,channel,user,ticket,reason,time}))
+                ticket.get("opendiscord:autoclose-enabled").value = true
+                ticket.get("opendiscord:autoclose-hours").value = time
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-enable").build(source,{guild,channel,user,ticket,reason,time}))
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on autoclose "+scope+"!","error",[
+                    opendiscord.log("Unable to edit ticket message on autoclose "+scope+"!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
            const scope = instance.options.getSubCommand()
            const reason = instance.options.getString("reason",false)
-            openticket.log(instance.user.displayName+" used the 'autoclose "+scope+"' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'autoclose "+scope+"' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,63 +1,63 @@
 ///////////////////////////////////////
 //AUTODELETE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //AUTODELETE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:autodelete",generalConfig.data.prefix,/^autodelete/))
-    openticket.responders.commands.get("openticket:autodelete").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:autodelete",generalConfig.data.prefix,/^autodelete/))
+    opendiscord.responders.commands.get("opendiscord:autodelete").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.autodelete
            
            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:autodelete",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:autodelete",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -66,38 +66,38 @@ export const registerCommandResponders = async () => {

            if (scope == "disable"){
                const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autodelete-enabled").value = false
-                ticket.get("openticket:autodelete-days").value = 0
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autodelete-disable").build(source,{guild,channel,user,ticket,reason}))
+                ticket.get("opendiscord:autodelete-enabled").value = false
+                ticket.get("opendiscord:autodelete-days").value = 0
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autodelete-disable").build(source,{guild,channel,user,ticket,reason}))
            
            }else if (scope == "enable"){
                const time = instance.options.getNumber("time",true)
                const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autodelete-enabled").value = true
-                ticket.get("openticket:autodelete-days").value = time
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autodelete-enable").build(source,{guild,channel,user,ticket,reason,time}))
+                ticket.get("opendiscord:autodelete-enabled").value = true
+                ticket.get("opendiscord:autodelete-days").value = time
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autodelete-enable").build(source,{guild,channel,user,ticket,reason,time}))
            }

            //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
            if (ticketMessage){
                try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                }catch(e){
-                    openticket.log("Unable to edit ticket message on autodelete "+scope+"!","error",[
+                    opendiscord.log("Unable to edit ticket message on autodelete "+scope+"!","error",[
                        {key:"channel",value:"#"+channel.name},
                        {key:"channelid",value:channel.id,hidden:true},
                        {key:"messageid",value:ticketMessage.id},
                        {key:"option",value:ticket.option.id.value}
                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                }
            }
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
            const scope = instance.options.getSubCommand()
            const reason = instance.options.getString("reason",false)
-            openticket.log(instance.user.displayName+" used the 'autodelete "+scope+"' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'autodelete "+scope+"' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,71 +1,71 @@
 ///////////////////////////////////////
 //BLACKLIST COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //BLACKLIST COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:blacklist",generalConfig.data.prefix,/^blacklist/))
-    openticket.responders.commands.get("openticket:blacklist").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:blacklist",generalConfig.data.prefix,/^blacklist/))
+    opendiscord.responders.commands.get("opendiscord:blacklist").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.blacklist
            
            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:blacklist",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:blacklist",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }
            const scope = instance.options.getSubCommand()
            if (!scope || (scope != "add" && scope != "get" && scope != "remove" && scope != "view")) return

            if (scope == "view"){
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-view").build(source,{guild,channel,user}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-view").build(source,{guild,channel,user}))
            
            }else if (scope == "get"){
                const data = instance.options.getUser("user",true)
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-get").build(source,{guild,channel,user,data}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-get").build(source,{guild,channel,user,data}))

            }else if (scope == "add"){
                const data = instance.options.getUser("user",true)
                const reason = instance.options.getString("reason",false)

-                openticket.blacklist.add(new api.ODBlacklist(data.id,reason),true)
-                openticket.log(instance.user.displayName+" added "+data.displayName+" to blacklist!","info",[
+                opendiscord.blacklist.add(new api.ODBlacklist(data.id,reason),true)
+                opendiscord.log(instance.user.displayName+" added "+data.displayName+" to blacklist!","info",[
                    {key:"user",value:user.username},
                    {key:"userid",value:user.id,hidden:true},
                    {key:"channelid",value:channel.id,hidden:true},
@@ -74,17 +74,17 @@ export const registerCommandResponders = async () => {
                ])

                //manage stats
-                await openticket.stats.get("openticket:global").setStat("openticket:users-blacklisted",1,"increase")
-                await openticket.stats.get("openticket:user").setStat("openticket:users-blacklisted",user.id,1,"increase")
+                await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:users-blacklisted",1,"increase")
+                await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:users-blacklisted",user.id,1,"increase")

-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-add").build(source,{guild,channel,user,data,reason}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-add").build(source,{guild,channel,user,data,reason}))

            }else if (scope == "remove"){
                const data = instance.options.getUser("user",true)
                const reason = instance.options.getString("reason",false)

-                openticket.blacklist.remove(data.id)
-                openticket.log(instance.user.displayName+" removed "+data.displayName+" from blacklist!","info",[
+                opendiscord.blacklist.remove(data.id)
+                opendiscord.log(instance.user.displayName+" removed "+data.displayName+" from blacklist!","info",[
                    {key:"user",value:user.username},
                    {key:"userid",value:user.id,hidden:true},
                    {key:"channelid",value:channel.id,hidden:true},
@@ -92,10 +92,10 @@ export const registerCommandResponders = async () => {
                    {key:"reason",value:reason ?? "/"}
                ])

-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-remove").build(source,{guild,channel,user,data,reason}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-remove").build(source,{guild,channel,user,data,reason}))
            }
        }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild) return
            
@@ -107,16 +107,16 @@ export const registerCommandResponders = async () => {

            //to logs
            if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.blacklisting.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:blacklist-logs").build(source,{guild,channel,user,mode:scope,data,reason}))
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-logs").build(source,{guild,channel,user,mode:scope,data,reason}))
            }

            //to dm
-            if (generalConfig.data.system.messages.blacklisting.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:blacklist-dm").build(source,{guild,channel,user,mode:scope,data,reason}))
+            if (generalConfig.data.system.messages.blacklisting.dm) await opendiscord.client.sendUserDm(user,await opendiscord.builders.messages.getSafe("opendiscord:blacklist-dm").build(source,{guild,channel,user,mode:scope,data,reason}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
            const scope = instance.options.getSubCommand()
-            openticket.log(instance.user.displayName+" used the 'blacklist "+scope+"' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'blacklist "+scope+"' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //CLAIM COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //CLAIM COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:claim",generalConfig.data.prefix,"claim"))
-    openticket.responders.commands.get("openticket:claim").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:claim",generalConfig.data.prefix,"claim"))
+    opendiscord.responders.commands.get("opendiscord:claim").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.claim

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:claim",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already claimed
-            if (ticket.get("openticket:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
+            if (ticket.get("opendiscord:claimed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -70,11 +70,11 @@ export const registerCommandResponders = async () => {

            //start claiming ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:claim-ticket").run(source,{guild,channel,user:claimUser,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:claim-message").build(source,{guild,channel,user:claimUser,ticket,reason}))
+            await opendiscord.actions.get("opendiscord:claim-ticket").run(source,{guild,channel,user:claimUser,ticket,reason,sendMessage:false})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build(source,{guild,channel,user:claimUser,ticket,reason}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'claim' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'claim' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -86,51 +86,51 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //CLAIM TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:claim-ticket",/^od:claim-ticket/))
-    openticket.responders.buttons.get("openticket:claim-ticket").workers.add(
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "ticket-message" && originalSource != "unclaim-message") return
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:claim-ticket",/^od:claim-ticket/))
+    opendiscord.responders.buttons.get("opendiscord:claim-ticket").workers.add(
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source,cancel) => {
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:claim-ticket"]["source"],"slash"|"text">
            
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:claim-ticket-ticket-message").activate(instance)
-            else await openticket.verifybars.get("openticket:claim-ticket-unclaim-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:claim-ticket-ticket-message").activate(instance)
+            else if (originalSource == "unclaim-message") await opendiscord.verifybars.get("opendiscord:claim-ticket-unclaim-message").activate(instance)
+            else await instance.defer("update",false)
        })
    )
 }

 export const registerModalResponders = async () => {
    //CLAIM WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:claim-ticket-reason",/^od:claim-ticket-reason_/))
-    openticket.responders.modals.get("openticket:claim-ticket-reason").workers.add([
-        new api.ODWorker("openticket:claim-ticket-reason",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:claim-ticket-reason",/^od:claim-ticket-reason_/))
+    opendiscord.responders.modals.get("opendiscord:claim-ticket-reason").workers.add([
+        new api.ODWorker("opendiscord:claim-ticket-reason",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) return
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }

-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"unclaim-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:claim-ticket"]["source"],"slash"|"text">
            const reason = instance.values.getTextField("reason",true)

            //claim with reason
            if (originalSource == "ticket-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }else if (originalSource == "unclaim-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:claim-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+                await opendiscord.actions.get("opendiscord:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build("other",{guild,channel,user,ticket,reason}))
+            }else{
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
            }
            
        })
@@ -1,81 +1,81 @@
 ///////////////////////////////////////
 //CLEAR COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //CLEAR COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:clear",generalConfig.data.prefix,"clear"))
-    openticket.responders.commands.get("openticket:clear").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:clear",generalConfig.data.prefix,"clear"))
+    opendiscord.responders.commands.get("opendiscord:clear").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.clear

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
                //only allow global admins (ticket admins aren't allowed to clear tickets)
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild,{allowChannelUserScope:false,allowChannelRoleScope:false}))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild,{allowChannelUserScope:false,allowChannelRoleScope:false}))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:clear",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:clear",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
            
            const tempFilter = instance.options.getString("filter",false)
            const filter = (tempFilter) ? tempFilter.toLowerCase() as api.ODTicketClearFilter : "all"
            const list: string[] = []
-            const ticketList = openticket.tickets.getAll().filter((ticket) => {
+            const ticketList = opendiscord.tickets.getAll().filter((ticket) => {
                if (filter == "all") return true
-                else if (filter == "open" && ticket.get("openticket:open").value) return true
-                else if (filter == "closed" && ticket.get("openticket:closed").value) return true
-                else if (filter == "claimed" && ticket.get("openticket:claimed").value) return true
-                else if (filter == "pinned" && ticket.get("openticket:pinned").value) return true
-                else if (filter == "unclaimed" && !ticket.get("openticket:claimed").value) return true
-                else if (filter == "unpinned" && !ticket.get("openticket:pinned").value) return true
-                else if (filter == "autoclosed" && ticket.get("openticket:closed").value) return true
+                else if (filter == "open" && ticket.get("opendiscord:open").value) return true
+                else if (filter == "closed" && ticket.get("opendiscord:closed").value) return true
+                else if (filter == "claimed" && ticket.get("opendiscord:claimed").value) return true
+                else if (filter == "pinned" && ticket.get("opendiscord:pinned").value) return true
+                else if (filter == "unclaimed" && !ticket.get("opendiscord:claimed").value) return true
+                else if (filter == "unpinned" && !ticket.get("opendiscord:pinned").value) return true
+                else if (filter == "autoclosed" && ticket.get("opendiscord:closed").value) return true
                else return false
            })
            for (const ticket of ticketList){
-                const ticketChannel = await openticket.tickets.getTicketChannel(ticket)
+                const ticketChannel = await opendiscord.tickets.getTicketChannel(ticket)
                if (ticketChannel) list.push("#"+ticketChannel.name)
            }

            //reply with clear verify
            await instance.defer(true)
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:clear-verify-message").build(source,{guild,channel,user,filter,list}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:clear-verify-message").build(source,{guild,channel,user,filter,list}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'clear' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'clear' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -87,36 +87,35 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //CLEAR CONTINUE BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:clear-continue",/^od:clear-continue_/))
-    openticket.responders.buttons.get("openticket:clear-continue").workers.add(
-        new api.ODWorker("openticket:clear-continue",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:clear-continue",/^od:clear-continue_/))
+    opendiscord.responders.buttons.get("opendiscord:clear-continue").workers.add(
+        new api.ODWorker("opendiscord:clear-continue",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild || channel.isDMBased()) return
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "slash" && originalSource != "text" && originalSource != "other") return
+            const originalSource = instance.interaction.customId.split("_")[1] as api.ODActionManagerIds_Default["opendiscord:clear-tickets"]["source"]
            const filter = instance.interaction.customId.split("_")[2] as api.ODTicketClearFilter
            
            //start ticket clear
-            instance.defer("update",true)
+            await instance.defer("update",true)
            const list: string[] = []
-            const ticketList = openticket.tickets.getAll().filter((ticket) => {
+            const ticketList = opendiscord.tickets.getAll().filter((ticket) => {
                if (filter == "all") return true
-                else if (filter == "open" && ticket.get("openticket:open").value) return true
-                else if (filter == "closed" && ticket.get("openticket:closed").value) return true
-                else if (filter == "claimed" && ticket.get("openticket:claimed").value) return true
-                else if (filter == "pinned" && ticket.get("openticket:pinned").value) return true
-                else if (filter == "unclaimed" && !ticket.get("openticket:claimed").value) return true
-                else if (filter == "unpinned" && !ticket.get("openticket:pinned").value) return true
-                else if (filter == "autoclosed" && ticket.get("openticket:closed").value) return true
+                else if (filter == "open" && ticket.get("opendiscord:open").value) return true
+                else if (filter == "closed" && ticket.get("opendiscord:closed").value) return true
+                else if (filter == "claimed" && ticket.get("opendiscord:claimed").value) return true
+                else if (filter == "pinned" && ticket.get("opendiscord:pinned").value) return true
+                else if (filter == "unclaimed" && !ticket.get("opendiscord:claimed").value) return true
+                else if (filter == "unpinned" && !ticket.get("opendiscord:pinned").value) return true
+                else if (filter == "autoclosed" && ticket.get("opendiscord:closed").value) return true
                else return false
            })
            for (const ticket of ticketList){
-                const ticketChannel = await openticket.tickets.getTicketChannel(ticket)
+                const ticketChannel = await opendiscord.tickets.getTicketChannel(ticket)
                if (ticketChannel) list.push("#"+ticketChannel.name)
            }

-            await openticket.actions.get("openticket:clear-tickets").run(originalSource,{guild,channel,user,filter,list:ticketList})
-            await instance.update(await openticket.builders.messages.getSafe("openticket:clear-message").build(originalSource,{guild,channel,user,filter,list}))
+            await opendiscord.actions.get("opendiscord:clear-tickets").run(originalSource,{guild,channel,user,filter,list:ticketList})
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:clear-message").build(originalSource,{guild,channel,user,filter,list}))
        })
    )
 }
@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //CLOSE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //CLOSE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:close",generalConfig.data.prefix,"close"))
-    openticket.responders.commands.get("openticket:close").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:close",generalConfig.data.prefix,"close"))
+    opendiscord.responders.commands.get("opendiscord:close").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.close

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:close",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already closed
-            if (ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+            if (ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -69,11 +69,11 @@ export const registerCommandResponders = async () => {

            //start closing ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:close-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:close-message").build(source,{guild,channel,user,ticket,reason}))
+            await opendiscord.actions.get("opendiscord:close-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build(source,{guild,channel,user,ticket,reason}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'close' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'close' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -85,51 +85,51 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //CLOSE TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:close-ticket",/^od:close-ticket_/))
-    openticket.responders.buttons.get("openticket:close-ticket").workers.add(
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "ticket-message" && originalSource != "reopen-message") return
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:close-ticket",/^od:close-ticket_/))
+    opendiscord.responders.buttons.get("opendiscord:close-ticket").workers.add(
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source,cancel) => {
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:close-ticket"]["source"],"slash"|"text"|"autoclose">
            
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:close-ticket-ticket-message").activate(instance)
-            else await openticket.verifybars.get("openticket:close-ticket-reopen-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:close-ticket-ticket-message").activate(instance)
+            else if (originalSource == "reopen-message") await opendiscord.verifybars.get("opendiscord:close-ticket-reopen-message").activate(instance)
+            else await instance.defer("update",false)
        })
    )
 }

 export const registerModalResponders = async () => {
    //CLOSE WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:close-ticket-reason",/^od:close-ticket-reason_/))
-    openticket.responders.modals.get("openticket:close-ticket-reason").workers.add([
-        new api.ODWorker("openticket:close-ticket-reason",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:close-ticket-reason",/^od:close-ticket-reason_/))
+    opendiscord.responders.modals.get("opendiscord:close-ticket-reason").workers.add([
+        new api.ODWorker("opendiscord:close-ticket-reason",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) return
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }

-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"reopen-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:close-ticket"]["source"],"slash"|"text"|"autoclose">
            const reason = instance.values.getTextField("reason",true)

            //close with reason
            if (originalSource == "ticket-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }else if (originalSource == "reopen-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+                await opendiscord.actions.get("opendiscord:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("other",{guild,channel,user,ticket,reason}))
+            }else{
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
            }
            
        })
@@ -1,62 +1,62 @@
 ///////////////////////////////////////
 //DELETE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //DELETE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:delete",generalConfig.data.prefix,"delete"))
-    openticket.responders.commands.get("openticket:delete").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:delete",generalConfig.data.prefix,"delete"))
+    opendiscord.responders.commands.get("opendiscord:delete").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.delete

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:delete",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -65,11 +65,11 @@ export const registerCommandResponders = async () => {

            //start deleting ticket
            await instance.defer(false)
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:delete-message").build(source,{guild,channel,user,ticket,reason}))
-            await openticket.actions.get("openticket:delete-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build(source,{guild,channel,user,ticket,reason}))
+            await opendiscord.actions.get("opendiscord:delete-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript})
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'delete' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'delete' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -81,68 +81,68 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //DELETE TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:delete-ticket",/^od:delete-ticket/))
-    openticket.responders.buttons.get("openticket:delete-ticket").workers.add(
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "ticket-message" && originalSource != "reopen-message" && originalSource != "close-message" && originalSource != "autoclose-message") return
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:delete-ticket",/^od:delete-ticket/))
+    opendiscord.responders.buttons.get("opendiscord:delete-ticket").workers.add(
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"],"slash"|"text"|"autodelete"|"clear">
            
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:delete-ticket-ticket-message").activate(instance)
-            else if (originalSource == "close-message") await openticket.verifybars.get("openticket:delete-ticket-close-message").activate(instance)
-            else if (originalSource == "reopen-message") await openticket.verifybars.get("openticket:delete-ticket-reopen-message").activate(instance)
-            else if (originalSource == "autoclose-message") await openticket.verifybars.get("openticket:delete-ticket-autoclose-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-ticket-message").activate(instance)
+            else if (originalSource == "close-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-close-message").activate(instance)
+            else if (originalSource == "reopen-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-reopen-message").activate(instance)
+            else if (originalSource == "autoclose-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-autoclose-message").activate(instance)
+            else await instance.defer("update",false)
        })
    )
 }

 export const registerModalResponders = async () => {
    //REOPEN WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:delete-ticket-reason",/^od:delete-ticket-reason_/))
-    openticket.responders.modals.get("openticket:delete-ticket-reason").workers.add([
-        new api.ODWorker("openticket:delete-ticket-reason",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:delete-ticket-reason",/^od:delete-ticket-reason_/))
+    opendiscord.responders.modals.get("opendiscord:delete-ticket-reason").workers.add([
+        new api.ODWorker("opendiscord:delete-ticket-reason",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) return
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }

-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"],"slash"|"text"|"autodelete"|"clear">
            const reason = instance.values.getTextField("reason",true)

            //delete with reason
            if (originalSource == "ticket-message"){
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
                //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                ticket.get("opendiscord:for-deletion").value = true
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }else if (originalSource == "close-message"){
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason}))
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason}))
            }else if (originalSource == "reopen-message"){
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason}))
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason}))
            }else if (originalSource == "autoclose-message"){
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason}))
+            }else{
                await instance.defer("update",false)
                //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
            }
        })
    ])
@@ -1,49 +1,49 @@
 ///////////////////////////////////////
 //HELP COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //HELP COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:help",generalConfig.data.prefix,"help"))
-    openticket.responders.commands.get("openticket:help").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:help",generalConfig.data.prefix,"help"))
+    opendiscord.responders.commands.get("opendiscord:help").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.help

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:help",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:help",0,async (instance,params,source,cancel) => {
            const preferSlashOverText = generalConfig.data.system.preferSlashOverText
            
            let mode: "slash"|"text"
@@ -53,10 +53,10 @@ export const registerCommandResponders = async () => {
            }else if (!generalConfig.data.slashCommands) mode = "text"
            else mode = "slash"
            
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:help-menu").build(source,{mode,page:0}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build(source,{mode,page:0}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'help' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'help' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -68,44 +68,44 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //HELP MENU SWITCH BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:help-menu-switch",/^od:help-menu-switch_(slash|text)/))
-    openticket.responders.buttons.get("openticket:help-menu-switch").workers.add(
-        new api.ODWorker("openticket:update-help-menu",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:help-menu-switch",/^od:help-menu-switch_(slash|text)/))
+    opendiscord.responders.buttons.get("opendiscord:help-menu-switch").workers.add(
+        new api.ODWorker("opendiscord:update-help-menu",0,async (instance,params,source,cancel) => {
            const mode = instance.interaction.customId.split("_")[1] as "slash"|"text"
            const pageButton = instance.getMessageComponent("button",/^od:help-menu-page_([0-9]+)/)
            const currentPage = (pageButton && pageButton.customId) ? Number(pageButton.customId.split("_")[1]) : 0

            const newMode = (mode == "slash") ? "text" : "slash"

-            const msg = await openticket.builders.messages.getSafe("openticket:help-menu").build("button",{mode:newMode,page:currentPage})
+            const msg = await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build("button",{mode:newMode,page:currentPage})
            await instance.update(msg)
        })
    )

    //HELP MENU PREVIOUS BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:help-menu-previous",/^od:help-menu-previous/))
-    openticket.responders.buttons.get("openticket:help-menu-previous").workers.add(
-        new api.ODWorker("openticket:update-help-menu",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:help-menu-previous",/^od:help-menu-previous/))
+    opendiscord.responders.buttons.get("opendiscord:help-menu-previous").workers.add(
+        new api.ODWorker("opendiscord:update-help-menu",0,async (instance,params,source,cancel) => {
            const switchButton = instance.getMessageComponent("button",/^od:help-menu-switch_(slash|text)/)
            const pageButton = instance.getMessageComponent("button",/^od:help-menu-page_([0-9]+)/)
            const currentPage = (pageButton && pageButton.customId) ? Number(pageButton.customId.split("_")[1]) : 0
            const currentMode = (switchButton && switchButton.customId) ? switchButton.customId.split("_")[1] as "text"|"slash" : "slash"

-            const msg = await openticket.builders.messages.getSafe("openticket:help-menu").build("button",{mode:currentMode,page:currentPage-1})
+            const msg = await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build("button",{mode:currentMode,page:currentPage-1})
            await instance.update(msg)
        })
    )

    //HELP MENU NEXT BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:help-menu-next",/^od:help-menu-next/))
-    openticket.responders.buttons.get("openticket:help-menu-next").workers.add(
-        new api.ODWorker("openticket:update-help-menu",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:help-menu-next",/^od:help-menu-next/))
+    opendiscord.responders.buttons.get("opendiscord:help-menu-next").workers.add(
+        new api.ODWorker("opendiscord:update-help-menu",0,async (instance,params,source,cancel) => {
            const switchButton = instance.getMessageComponent("button",/^od:help-menu-switch_(slash|text)/)
            const pageButton = instance.getMessageComponent("button",/^od:help-menu-page_([0-9]+)/)
            const currentPage = (pageButton && pageButton.customId) ? Number(pageButton.customId.split("_")[1]) : 0
            const currentMode = (switchButton && switchButton.customId) ? switchButton.customId.split("_")[1] as "text"|"slash" : "slash"

-            const msg = await openticket.builders.messages.getSafe("openticket:help-menu").build("button",{mode:currentMode,page:currentPage+1})
+            const msg = await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build("button",{mode:currentMode,page:currentPage+1})
            await instance.update(msg)
        })
    )
@@ -1,87 +1,87 @@
 ///////////////////////////////////////
 //MOVE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //MOVE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:move",generalConfig.data.prefix,"move"))
-    openticket.responders.commands.get("openticket:move").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:move",generalConfig.data.prefix,"move"))
+    opendiscord.responders.commands.get("opendiscord:move").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.move

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:move",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:move",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

            const id = instance.options.getString("id",true)
            const reason = instance.options.getString("reason",false)

-            const option = openticket.options.get(id)
+            const option = opendiscord.options.get(id)
            //return if unknown option
            if (!option || !(option instanceof api.ODTicketOption)){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.titles.unknownOption"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.titles.unknownOption"),layout:"simple"}))
                return cancel()
            }
            //return if option is the same
            if (ticket.option.id.value == option.id.value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:"This ticket is already the same as the chosen option!",layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:"This ticket is already the same as the chosen option!",layout:"simple"}))
                return cancel()
            }

            //start moving ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:move-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data:option})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:move-message").build(source,{guild,channel,user,ticket,reason,data:option}))
+            await opendiscord.actions.get("opendiscord:move-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data:option})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:move-message").build(source,{guild,channel,user,ticket,reason,data:option}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'move' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'move' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,77 +1,80 @@
 ///////////////////////////////////////
 //STATS COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //PANEL COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:panel",generalConfig.data.prefix,/^panel/))
-    openticket.responders.commands.get("openticket:panel").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:panel",generalConfig.data.prefix,/^panel/))
+    opendiscord.responders.commands.get("opendiscord:panel").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.panel
            
            //command is disabled
            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:panel",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:panel",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild || instance.channel.type == discord.ChannelType.GroupDM){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }
            
            const id = instance.options.getString("id",true)
-            const panel = openticket.panels.get(id)
+            const panel = opendiscord.panels.get(id)

            if (!panel){
                //invalid panel
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-panel-unknown").build(source,{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-panel-unknown").build(source,{guild,channel,user}))
                return cancel()
            } 
            
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:panel-ready").build(source,{guild,channel,user,panel}))
-            const panelMessage = await instance.channel.send((await openticket.builders.messages.getSafe("openticket:panel").build(source,{guild,channel,user,panel})).message)
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:panel-ready").build(source,{guild,channel,user,panel}))
+            const panelMessage = await instance.channel.send((await opendiscord.builders.messages.getSafe("opendiscord:panel").build(source,{guild,channel,user,panel})).message)

-            //add panel to database on auto-update
+            //add panel to database (this way, the bot knows where all panels are located)
+            const globalDatabase = opendiscord.databases.get("opendiscord:global")
+            await globalDatabase.set("opendiscord:panel-message",panelMessage.channel.id+"_"+panelMessage.id,panel.id.value)
+            
+            //add panel to database for auto-update
            if (instance.options.getBoolean("auto-update",false)){
-                const globalDatabase = openticket.databases.get("openticket:global")
-                await globalDatabase.set("openticket:panel-update",panelMessage.channel.id+"_"+panelMessage.id,panel.id.value)
+                await globalDatabase.set("opendiscord:panel-update",panelMessage.channel.id+"_"+panelMessage.id,panel.id.value)
            }
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'panel' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'panel' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //PIN COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //PIN COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:pin",generalConfig.data.prefix,"pin"))
-    openticket.responders.commands.get("openticket:pin").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:pin",generalConfig.data.prefix,"pin"))
+    opendiscord.responders.commands.get("opendiscord:pin").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.pin

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:pin",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when already pinned
-            if (ticket.get("openticket:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
+            if (ticket.get("opendiscord:pinned").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -69,11 +69,11 @@ export const registerCommandResponders = async () => {

            //start pinning ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:pin-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:pin-message").build(source,{guild,channel,user,ticket,reason}))
+            await opendiscord.actions.get("opendiscord:pin-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build(source,{guild,channel,user,ticket,reason}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'pin' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'pin' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -85,51 +85,51 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //PIN TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:pin-ticket",/^od:pin-ticket/))
-    openticket.responders.buttons.get("openticket:pin-ticket").workers.add(
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "ticket-message" && originalSource != "unpin-message") return
-            
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:pin-ticket-ticket-message").activate(instance)
-            else await openticket.verifybars.get("openticket:pin-ticket-unpin-message").activate(instance)
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:pin-ticket",/^od:pin-ticket/))
+    opendiscord.responders.buttons.get("opendiscord:pin-ticket").workers.add(
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source,cancel) => {
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:pin-ticket"]["source"],"slash"|"text">
+
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:pin-ticket-ticket-message").activate(instance)
+            else if (originalSource == "unpin-message") await opendiscord.verifybars.get("opendiscord:pin-ticket-unpin-message").activate(instance)
+            else await instance.defer("update",false)
        })
    )
 }

 export const registerModalResponders = async () => {
    //PIN WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:pin-ticket-reason",/^od:pin-ticket-reason_/))
-    openticket.responders.modals.get("openticket:pin-ticket-reason").workers.add([
-        new api.ODWorker("openticket:pin-ticket-reason",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:pin-ticket-reason",/^od:pin-ticket-reason_/))
+    opendiscord.responders.modals.get("opendiscord:pin-ticket-reason").workers.add([
+        new api.ODWorker("opendiscord:pin-ticket-reason",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) return
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }

-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"unpin-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:pin-ticket"]["source"],"slash"|"text">
            const reason = instance.values.getTextField("reason",true)

            //pin with reason
            if (originalSource == "ticket-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }else if (originalSource == "unpin-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:pin-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+                await opendiscord.actions.get("opendiscord:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build("other",{guild,channel,user,ticket,reason}))
+            }else{
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
            }
            
        })
@@ -1,62 +1,62 @@
 ///////////////////////////////////////
 //REMOVE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //REMOVE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:remove",generalConfig.data.prefix,"remove"))
-    openticket.responders.commands.get("openticket:remove").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:remove",generalConfig.data.prefix,"remove"))
+    opendiscord.responders.commands.get("opendiscord:remove").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.remove

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:remove",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:remove",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -64,19 +64,19 @@ export const registerCommandResponders = async () => {
            const reason = instance.options.getString("reason",false)

            //return when user is not a participant of the ticket (admins & creator can't be removed)
-            const participants = await openticket.tickets.getAllTicketParticipants(ticket)
+            const participants = await opendiscord.tickets.getAllTicketParticipants(ticket)
            if (!participants || !participants.find((p) => p.user.id == data.id && p.role == "participant")){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.remove"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.remove"),layout:"simple"}))
                return cancel()
            }

            //start removing user from ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:remove-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:remove-message").build(source,{guild,channel,user,ticket,reason,data}))
+            await opendiscord.actions.get("opendiscord:remove-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:remove-message").build(source,{guild,channel,user,ticket,reason,data}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'remove' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'remove' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,62 +1,62 @@
 ///////////////////////////////////////
 //RENAME COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //RENAME COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:rename",generalConfig.data.prefix,"rename"))
-    openticket.responders.commands.get("openticket:rename").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:rename",generalConfig.data.prefix,"rename"))
+    opendiscord.responders.commands.get("opendiscord:rename").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.rename

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:rename",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:rename",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -65,11 +65,11 @@ export const registerCommandResponders = async () => {

            //start renaming ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:rename-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data:name})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:rename-message").build(source,{guild,channel,user,ticket,reason,data:name}))
+            await opendiscord.actions.get("opendiscord:rename-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data:name})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:rename-message").build(source,{guild,channel,user,ticket,reason,data:name}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'rename' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'rename' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //REOPEN COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //REOPEN COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:reopen",generalConfig.data.prefix,"reopen"))
-    openticket.responders.commands.get("openticket:reopen").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:reopen",generalConfig.data.prefix,"reopen"))
+    opendiscord.responders.commands.get("opendiscord:reopen").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.reopen

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:reopen",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not closed
-            if (!ticket.get("openticket:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
+            if (!ticket.get("opendiscord:closed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -69,11 +69,11 @@ export const registerCommandResponders = async () => {

            //start reopening ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:reopen-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:reopen-message").build(source,{guild,channel,user,ticket,reason}))
+            await opendiscord.actions.get("opendiscord:reopen-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build(source,{guild,channel,user,ticket,reason}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'reopen' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'reopen' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -85,56 +85,56 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //REOPEN TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:reopen-ticket",/^od:reopen-ticket/))
-    openticket.responders.buttons.get("openticket:reopen-ticket").workers.add(
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "ticket-message" && originalSource != "close-message" && originalSource != "autoclose-message") return
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:reopen-ticket",/^od:reopen-ticket/))
+    opendiscord.responders.buttons.get("opendiscord:reopen-ticket").workers.add(
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source,cancel) => {
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:reopen-ticket"]["source"],"slash"|"text">
            
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:reopen-ticket-ticket-message").activate(instance)
-            else if (originalSource == "close-message") await openticket.verifybars.get("openticket:reopen-ticket-close-message").activate(instance)
-            else await openticket.verifybars.get("openticket:reopen-ticket-autoclose-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:reopen-ticket-ticket-message").activate(instance)
+            else if (originalSource == "close-message") await opendiscord.verifybars.get("opendiscord:reopen-ticket-close-message").activate(instance)
+            else if (originalSource == "autoclose-message") await opendiscord.verifybars.get("opendiscord:reopen-ticket-autoclose-message").activate(instance)
+            else await instance.defer("update",false)
        })
    )
 }

 export const registerModalResponders = async () => {
    //REOPEN WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:reopen-ticket-reason",/^od:reopen-ticket-reason_/))
-    openticket.responders.modals.get("openticket:reopen-ticket-reason").workers.add([
-        new api.ODWorker("openticket:reopen-ticket-reason",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:reopen-ticket-reason",/^od:reopen-ticket-reason_/))
+    opendiscord.responders.modals.get("opendiscord:reopen-ticket-reason").workers.add([
+        new api.ODWorker("opendiscord:reopen-ticket-reason",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) return
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }

-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"close-message"|"autoclose-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:reopen-ticket"]["source"],"slash"|"text">
            const reason = instance.values.getTextField("reason",true)

            //reopen with reason
            if (originalSource == "ticket-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }else if (originalSource == "close-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("other",{guild,channel,user,ticket,reason}))
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("other",{guild,channel,user,ticket,reason}))
            }else if (originalSource == "autoclose-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("other",{guild,channel,user,ticket,reason}))
+            }else{
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
            }
            
        })
@@ -1,41 +1,41 @@
 ///////////////////////////////////////
 //ROLE BUTTON (not command)
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerButtonResponders = async () => {
    //ROLE OPTION BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:role-option",/^od:role-option_/))
-    openticket.responders.buttons.get("openticket:role-option").workers.add(
-        new api.ODWorker("openticket:role-option",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:role-option",/^od:role-option_/))
+    opendiscord.responders.buttons.get("opendiscord:role-option").workers.add(
+        new api.ODWorker("opendiscord:role-option",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //get option
            const optionId = instance.interaction.customId.split("_")[2]
-            const option = openticket.options.get(optionId)
+            const option = opendiscord.options.get(optionId)
            if (!option || !(option instanceof api.ODRoleOption)){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //reaction role
            await instance.defer("reply",true)
-            const res = await openticket.actions.get("openticket:reaction-role").run("panel-button",{guild,user,option,overwriteMode:null})
+            const res = await opendiscord.actions.get("opendiscord:reaction-role").run("panel-button",{guild,user,option,overwriteMode:null})
            if (!res.result || !res.role){
                //error
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive role update data from worker!",layout:"advanced"}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive role update data from worker!",layout:"advanced"}))
                return cancel()
            }
-            if (generalConfig.data.system.replyOnReactionRole) await instance.reply(await openticket.builders.messages.getSafe("openticket:reaction-role").build("panel-button",{guild,user,role:res.role,result:res.result}))
+            if (generalConfig.data.system.replyOnReactionRole) await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:reaction-role").build("panel-button",{guild,user,role:res.role,result:res.result}))
        })
    )
 }
@@ -1,30 +1,30 @@
 ///////////////////////////////////////
 //STATS COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //STATS COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:stats",generalConfig.data.prefix,/^stats/))
-    openticket.responders.commands.get("openticket:stats").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:stats",generalConfig.data.prefix,/^stats/))
+    opendiscord.responders.commands.get("opendiscord:stats").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.stats
            
            //command is disabled
            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }

            //reset subcommand is owner/developer only
            if (instance.options.getSubCommand() == "reset"){
-                if (!openticket.permissions.hasPermissions("owner",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("owner",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["owner","developer"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["owner","developer"]}))
                    return cancel()
                }else return
            }
@@ -32,62 +32,62 @@ export const registerCommandResponders = async () => {
            //permissions for normal scopes
            if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:stats",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:stats",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }
            const scope = instance.options.getSubCommand()
            if (!scope || (scope != "global" && scope != "ticket" && scope != "user" && scope != "reset")) return

            if (scope == "global"){
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:stats-global").build(source,{guild,channel,user}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:stats-global").build(source,{guild,channel,user}))
            
            }else if (scope == "ticket"){
                const id = instance.options.getChannel("ticket",false)?.id ?? channel.id
-                const ticket = openticket.tickets.get(id)
+                const ticket = opendiscord.tickets.get(id)
                
-                if (ticket) await instance.reply(await openticket.builders.messages.getSafe("openticket:stats-ticket").build(source,{guild,channel,user,scopeData:ticket}))
-                else await instance.reply(await openticket.builders.messages.getSafe("openticket:stats-ticket-unknown").build(source,{guild,channel,user,id}))
+                if (ticket) await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:stats-ticket").build(source,{guild,channel,user,scopeData:ticket}))
+                else await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:stats-ticket-unknown").build(source,{guild,channel,user,id}))

            }else if (scope == "user"){
                const statsUser = instance.options.getUser("user",false) ?? user
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:stats-user").build(source,{guild,channel,user,scopeData:statsUser}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:stats-user").build(source,{guild,channel,user,scopeData:statsUser}))

            }else if (scope == "reset"){
                const reason = instance.options.getString("reason",false)
-                openticket.stats.reset()
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:stats-reset").build(source,{guild,channel,user,reason}))
+                opendiscord.stats.reset()
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:stats-reset").build(source,{guild,channel,user,reason}))

            }
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
            const scope = instance.options.getSubCommand()
            let data: string
            if (scope == "ticket"){
@@ -95,7 +95,7 @@ export const registerCommandResponders = async () => {
            }else if (scope == "user"){
                data = instance.options.getUser("user",false)?.id ?? instance.user.id
            }else data = "/"
-            openticket.log(instance.user.displayName+" used the 'stats "+scope+"' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'stats "+scope+"' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -1,97 +1,97 @@
 ///////////////////////////////////////
 //TICKET COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //TICKET COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:ticket",generalConfig.data.prefix,/^ticket/))
-    openticket.responders.commands.get("openticket:ticket").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:ticket",generalConfig.data.prefix,/^ticket/))
+    opendiscord.responders.commands.get("opendiscord:ticket").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.ticket
            
            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:ticket",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //get option
            const optionId = instance.options.getString("id",true)
-            const option = openticket.options.get(optionId)
+            const option = opendiscord.options.get(optionId)
            if (!option || !(option instanceof api.ODTicketOption)){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //check ticket permissions
-            const res = await openticket.actions.get("openticket:create-ticket-permissions").run(source,{guild,user,option})
+            const res = await opendiscord.actions.get("opendiscord:create-ticket-permissions").run(source,{guild,user,option})
            if (!res.valid){
                //error
-                if (res.reason == "blacklist") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-blacklisted").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
-                else if (res.reason == "cooldown") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-cooldown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,until:res.cooldownUntil}))
-                else if (res.reason == "global-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global"}))
-                else if (res.reason == "global-user-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global-user"}))
-                else if (res.reason == "option-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option"}))
-                else if (res.reason == "option-user-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option-user"}))
-                else instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Unknown invalid_permission reason => calculation failed #1",layout:"advanced"}))
+                if (res.reason == "blacklist") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-blacklisted").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
+                else if (res.reason == "cooldown") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-cooldown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,until:res.cooldownUntil}))
+                else if (res.reason == "global-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global"}))
+                else if (res.reason == "global-user-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global-user"}))
+                else if (res.reason == "option-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option"}))
+                else if (res.reason == "option-user-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option-user"}))
+                else instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Unknown invalid_permission reason => calculation failed #1",layout:"advanced"}))
                return cancel()
            }

            //start ticket creation
-            if (option.exists("openticket:questions") && option.get("openticket:questions").value.length > 0){
+            if (option.exists("opendiscord:questions") && option.get("opendiscord:questions").value.length > 0){
                //send modal
-                instance.modal(await openticket.builders.modals.getSafe("openticket:ticket-questions").build(source,{guild,channel,user,option}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:ticket-questions").build(source,{guild,channel,user,option}))
            }else{
                //create ticket
                await instance.defer(true)
-                const res = await openticket.actions.get("openticket:create-ticket").run(source,{guild,user,answers:[],option})
+                const res = await opendiscord.actions.get("opendiscord:create-ticket").run(source,{guild,user,answers:[],option})
                if (!res.channel || !res.ticket){
                    //error
-                    await instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive ticket or channel from callback! #1",layout:"advanced"}))
+                    await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive ticket or channel from callback! #1",layout:"advanced"}))
                    return cancel()
                }
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:ticket-created").build(source,{guild,channel:res.channel,user,ticket:res.ticket}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:ticket-created").build(source,{guild,channel:res.channel,user,ticket:res.ticket}))
            }
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'ticket' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'ticket' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -103,53 +103,54 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //TICKET OPTION BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:ticket-option",/^od:ticket-option_/))
-    openticket.responders.buttons.get("openticket:ticket-option").workers.add(
-        new api.ODWorker("openticket:ticket-option",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:ticket-option",/^od:ticket-option_/))
+    opendiscord.responders.buttons.get("opendiscord:ticket-option").workers.add(
+        new api.ODWorker("opendiscord:ticket-option",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //get option
            const optionId = instance.interaction.customId.split("_")[2]
-            const option = openticket.options.get(optionId)
+            const option = opendiscord.options.get(optionId)
            if (!option || !(option instanceof api.ODTicketOption)){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //check ticket permissions
-            const res = await openticket.actions.get("openticket:create-ticket-permissions").run("panel-button",{guild,user,option})
+            const res = await opendiscord.actions.get("opendiscord:create-ticket-permissions").run("panel-button",{guild,user,option})
            if (!res.valid){
                //error
-                if (res.reason == "blacklist") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-blacklisted").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
-                else if (res.reason == "cooldown") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-cooldown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,until:res.cooldownUntil}))
-                else if (res.reason == "global-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global"}))
-                else if (res.reason == "global-user-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global-user"}))
-                else if (res.reason == "option-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option"}))
-                else if (res.reason == "option-user-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option-user"}))
-                else instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Unknown invalid_permission reason => calculation failed #1",layout:"advanced"}))
+                if (res.reason == "blacklist") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-blacklisted").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
+                else if (res.reason == "cooldown") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-cooldown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,until:res.cooldownUntil}))
+                else if (res.reason == "global-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global"}))
+                else if (res.reason == "global-user-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global-user"}))
+                else if (res.reason == "option-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option"}))
+                else if (res.reason == "option-user-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option-user"}))
+                else instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Unknown invalid_permission reason => calculation failed #1",layout:"advanced"}))
                return cancel()
            }

            //start ticket creation
-            if (option.exists("openticket:questions") && option.get("openticket:questions").value.length > 0){
+            if (option.exists("opendiscord:questions") && option.get("opendiscord:questions").value.length > 0){
                //send modal
-                instance.modal(await openticket.builders.modals.getSafe("openticket:ticket-questions").build("panel-button",{guild,channel,user,option}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:ticket-questions").build("panel-button",{guild,channel,user,option}))
            }else{
                //create ticket
-                await instance.defer("reply",true)
-                const res = await openticket.actions.get("openticket:create-ticket").run("panel-button",{guild,user,answers:[],option})
+                await instance.defer((generalConfig.data.system.replyOnTicketCreation) ? "reply" : "update",true)
+
+                const res = await opendiscord.actions.get("opendiscord:create-ticket").run("panel-button",{guild,user,answers:[],option})
                if (!res.channel || !res.ticket){
                    //error
-                    await instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive ticket or channel from callback! #1",layout:"advanced"}))
+                    await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive ticket or channel from callback! #1",layout:"advanced"}))
                    return cancel()
                }
-                if (generalConfig.data.system.replyOnTicketCreation) await instance.reply(await openticket.builders.messages.getSafe("openticket:ticket-created").build("panel-button",{guild,channel:res.channel,user,ticket:res.ticket}))
+                if (generalConfig.data.system.replyOnTicketCreation) await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:ticket-created").build("panel-button",{guild,channel:res.channel,user,ticket:res.ticket}))
            }
        })
    )
@@ -157,53 +158,62 @@ export const registerButtonResponders = async () => {

 export const registerDropdownResponders = async () => {
    //PANEL DROPDOWN TICKETS DROPDOWN RESPONDER
-    openticket.responders.dropdowns.add(new api.ODDropdownResponder("openticket:panel-dropdown-tickets",/^od:panel-dropdown_/))
-    openticket.responders.dropdowns.get("openticket:panel-dropdown-tickets").workers.add(
-        new api.ODWorker("openticket:panel-dropdown-tickets",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.dropdowns.add(new api.ODDropdownResponder("opendiscord:panel-dropdown-tickets",/^od:panel-dropdown_/))
+    opendiscord.responders.dropdowns.get("opendiscord:panel-dropdown-tickets").workers.add(
+        new api.ODWorker("opendiscord:panel-dropdown-tickets",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //get option
            const optionId = instance.values.getStringValues()[0].split("_")[2]
-            const option = openticket.options.get(optionId)
+            const option = opendiscord.options.get(optionId)
            if (!option || !(option instanceof api.ODTicketOption)){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-option-unknown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
                return cancel()
            }

            //check ticket permissions
-            const res = await openticket.actions.get("openticket:create-ticket-permissions").run("panel-dropdown",{guild,user,option})
+            const res = await opendiscord.actions.get("opendiscord:create-ticket-permissions").run("panel-dropdown",{guild,user,option})
            if (!res.valid){
                //error
-                if (res.reason == "blacklist") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-blacklisted").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
-                else if (res.reason == "cooldown") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-cooldown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,until:res.cooldownUntil}))
-                else if (res.reason == "global-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global"}))
-                else if (res.reason == "global-user-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global-user"}))
-                else if (res.reason == "option-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option"}))
-                else if (res.reason == "option-user-limit") instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option-user"}))
-                else instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Unknown invalid_permission reason => calculation failed #1",layout:"advanced"}))
+                if (res.reason == "blacklist") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-blacklisted").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user}))
+                else if (res.reason == "cooldown") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-cooldown").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,until:res.cooldownUntil}))
+                else if (res.reason == "global-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global"}))
+                else if (res.reason == "global-user-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"global-user"}))
+                else if (res.reason == "option-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option"}))
+                else if (res.reason == "option-user-limit") instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions-limits").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,limit:"option-user"}))
+                else instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Unknown invalid_permission reason => calculation failed #1",layout:"advanced"}))
                return cancel()
            }

            //start ticket creation
-            if (option.exists("openticket:questions") && option.get("openticket:questions").value.length > 0){
+            if (option.exists("opendiscord:questions") && option.get("opendiscord:questions").value.length > 0){
                //send modal
-                instance.modal(await openticket.builders.modals.getSafe("openticket:ticket-questions").build("panel-dropdown",{guild,channel,user,option}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:ticket-questions").build("panel-dropdown",{guild,channel,user,option}))
            }else{
                //create ticket
-                await instance.defer("reply",true)
-                const res = await openticket.actions.get("openticket:create-ticket").run("panel-dropdown",{guild,user,answers:[],option})
+                await instance.defer((generalConfig.data.system.replyOnTicketCreation) ? "reply" : "update",true)
+
+                const res = await opendiscord.actions.get("opendiscord:create-ticket").run("panel-dropdown",{guild,user,answers:[],option})
                if (!res.channel || !res.ticket){
                    //error
-                    await instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive ticket or channel from callback! #1",layout:"advanced"}))
+                    await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild,channel:instance.channel,user,error:"Unable to receive ticket or channel from callback! #1",layout:"advanced"}))
                    return cancel()
                }
-                if (generalConfig.data.system.replyOnTicketCreation) await instance.reply(await openticket.builders.messages.getSafe("openticket:ticket-created").build("panel-dropdown",{guild,channel:res.channel,user,ticket:res.ticket}))
+                if (generalConfig.data.system.replyOnTicketCreation) await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:ticket-created").build("panel-dropdown",{guild,channel:res.channel,user,ticket:res.ticket}))
+            }
+
+            //update panel after dropdown usage (reset panel choice)
+            const globalDatabase = opendiscord.databases.get("opendiscord:global")
+            const rawPanelId = await globalDatabase.get("opendiscord:panel-message",instance.message.channel.id+"_"+instance.message.id)
+            if (rawPanelId){
+                const panel = opendiscord.panels.get(rawPanelId)
+                if (panel) await instance.message.edit((await opendiscord.builders.messages.getSafe("opendiscord:panel").build("auto-update",{guild,channel,user,panel})).message)
            }
        })
    )
@@ -211,14 +221,14 @@ export const registerDropdownResponders = async () => {

 export const registerModalResponders = async () => {
    //TICKET QUESTIONS RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:ticket-questions",/^od:ticket-questions_/))
-    openticket.responders.modals.get("openticket:ticket-questions").workers.add([
-        new api.ODWorker("openticket:ticket-questions",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:ticket-questions",/^od:ticket-questions_/))
+    opendiscord.responders.modals.get("opendiscord:ticket-questions").workers.add([
+        new api.ODWorker("opendiscord:ticket-questions",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) throw new api.ODSystemError("The 'Ticket Questions' modal requires a channel for responding!")
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }

@@ -226,29 +236,29 @@ export const registerModalResponders = async () => {

            //get option
            const optionId = instance.interaction.customId.split("_")[1]
-            const option = openticket.options.get(optionId)
+            const option = opendiscord.options.get(optionId)
            if (!option || !(option instanceof api.ODTicketOption)){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-option-unknown").build(source,{guild:instance.guild,channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-option-unknown").build(source,{guild:instance.guild,channel,user:instance.user}))
                return cancel()
            }

            //get answers
            const answers: {id:string,name:string,type:"short"|"paragraph",value:string|null}[] = []
-            option.get("openticket:questions").value.forEach((id) => {
-                const question = openticket.questions.get(id)
+            option.get("opendiscord:questions").value.forEach((id) => {
+                const question = opendiscord.questions.get(id)
                if (!question) return
                if (question instanceof api.ODShortQuestion){
                    answers.push({
                        id,
-                        name:question.exists("openticket:name") ? question.get("openticket:name")?.value : id,
+                        name:question.exists("opendiscord:name") ? question.get("opendiscord:name")?.value : id,
                        type:"short",
                        value:instance.values.getTextField(id,false)
                    })
                }else if (question instanceof api.ODParagraphQuestion){
                    answers.push({
                        id,
-                        name:question.exists("openticket:name") ? question.get("openticket:name")?.value : id,
+                        name:question.exists("opendiscord:name") ? question.get("opendiscord:name")?.value : id,
                        type:"paragraph",
                        value:instance.values.getTextField(id,false)
                    })
@@ -256,14 +266,15 @@ export const registerModalResponders = async () => {
            })

            //create ticket
-            await instance.defer("reply",true)
-            const res = await openticket.actions.get("openticket:create-ticket").run(originalSource,{guild,user,answers,option})
+            await instance.defer((generalConfig.data.system.replyOnTicketCreation) ? "reply" : "update",true)
+            
+            const res = await opendiscord.actions.get("opendiscord:create-ticket").run(originalSource,{guild,user,answers,option})
            if (!res.channel || !res.ticket){
                //error
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild,channel,user,error:"Unable to receive ticket or channel from callback! #2",layout:"advanced"}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild,channel,user,error:"Unable to receive ticket or channel from callback! #2",layout:"advanced"}))
                return cancel()
            }
-            if (generalConfig.data.system.replyOnTicketCreation) await instance.reply(await openticket.builders.messages.getSafe("openticket:ticket-created").build(originalSource,{guild,channel:res.channel,user,ticket:res.ticket}))
+            if (generalConfig.data.system.replyOnTicketCreation) await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:ticket-created").build(originalSource,{guild,channel:res.channel,user,ticket:res.ticket}))
        })
    ])
 }
@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //UNCLAIM COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //UNCLAIM COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:unclaim",generalConfig.data.prefix,"unclaim"))
-    openticket.responders.commands.get("openticket:unclaim").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:unclaim",generalConfig.data.prefix,"unclaim"))
+    opendiscord.responders.commands.get("opendiscord:unclaim").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.unclaim

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:unclaim",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unclaim",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not claimed
-            if (!ticket.get("openticket:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
+            if (!ticket.get("opendiscord:claimed").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -69,11 +69,11 @@ export const registerCommandResponders = async () => {

            //start unclaiming ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:unclaim-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:unclaim-message").build(source,{guild,channel,user,ticket,reason}))
+            await opendiscord.actions.get("opendiscord:unclaim-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build(source,{guild,channel,user,ticket,reason}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'unclaim' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'unclaim' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -85,51 +85,51 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //UNCLAIM TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:unclaim-ticket",/^od:unclaim-ticket/))
-    openticket.responders.buttons.get("openticket:unclaim-ticket").workers.add(
-        new api.ODWorker("openticket:unclaim-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "ticket-message" && originalSource != "claim-message") return
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:unclaim-ticket",/^od:unclaim-ticket/))
+    opendiscord.responders.buttons.get("opendiscord:unclaim-ticket").workers.add(
+        new api.ODWorker("opendiscord:unclaim-ticket",0,async (instance,params,source,cancel) => {
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:unclaim-ticket"]["source"],"slash"|"text">
            
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:unclaim-ticket-ticket-message").activate(instance)
-            else await openticket.verifybars.get("openticket:unclaim-ticket-claim-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:unclaim-ticket-ticket-message").activate(instance)
+            else if (originalSource == "claim-message") await opendiscord.verifybars.get("opendiscord:unclaim-ticket-claim-message").activate(instance)
+            else await instance.defer("update",false)
        })
    )
 }

 export const registerModalResponders = async () => {
    //UNCLAIM WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:unclaim-ticket-reason",/^od:unclaim-ticket-reason_/))
-    openticket.responders.modals.get("openticket:unclaim-ticket-reason").workers.add([
-        new api.ODWorker("openticket:unclaim-ticket-reason",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:unclaim-ticket-reason",/^od:unclaim-ticket-reason_/))
+    opendiscord.responders.modals.get("opendiscord:unclaim-ticket-reason").workers.add([
+        new api.ODWorker("opendiscord:unclaim-ticket-reason",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) return
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }

-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"claim-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:unclaim-ticket"]["source"],"slash"|"text">
            const reason = instance.values.getTextField("reason",true)

            //unclaim with reason
            if (originalSource == "ticket-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unclaim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:unclaim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }else if (originalSource == "claim-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unclaim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:unclaim-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+                await opendiscord.actions.get("opendiscord:unclaim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build("other",{guild,channel,user,ticket,reason}))
+            }else{
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unclaim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:unclaim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
            }
        })
    ])
@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //UNPIN COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"

-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")

 export const registerCommandResponders = async () => {
    //UNPIN COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:unpin",generalConfig.data.prefix,"unpin"))
-    openticket.responders.commands.get("openticket:unpin").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:unpin",generalConfig.data.prefix,"unpin"))
+    opendiscord.responders.commands.get("opendiscord:unpin").workers.add([
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
            const permissionMode = generalConfig.data.system.permissions.unpin

            if (permissionMode == "none"){
                //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                return cancel()
            }else if (permissionMode == "everyone") return
            else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                    return cancel()
                }else return
            }else{
                if (!instance.guild || !instance.member){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                    return cancel()
                }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                if (!role){
                    //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                    return cancel()
                }
                if (!role.members.has(instance.member.id)){
                    //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                    return cancel()
                }else return
            }
        }),
-        new api.ODWorker("openticket:unpin",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unpin",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return cancel()
            }
            //return when not pinned yet
-            if (!ticket.get("openticket:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
+            if (!ticket.get("opendiscord:pinned").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
                return cancel()
            }
            //return when busy
-            if (ticket.get("openticket:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+            if (ticket.get("opendiscord:busy").value){
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                return cancel()
            }

@@ -69,11 +69,11 @@ export const registerCommandResponders = async () => {

            //start unpinning ticket
            await instance.defer(false)
-            await openticket.actions.get("openticket:unpin-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:unpin-message").build(source,{guild,channel,user,ticket,reason}))
+            await opendiscord.actions.get("opendiscord:unpin-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build(source,{guild,channel,user,ticket,reason}))
        }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'unpin' command!","info",[
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
+            opendiscord.log(instance.user.displayName+" used the 'unpin' command!","info",[
                {key:"user",value:instance.user.username},
                {key:"userid",value:instance.user.id,hidden:true},
                {key:"channelid",value:instance.channel.id,hidden:true},
@@ -85,51 +85,51 @@ export const registerCommandResponders = async () => {

 export const registerButtonResponders = async () => {
    //UNPIN TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:unpin-ticket",/^od:unpin-ticket/))
-    openticket.responders.buttons.get("openticket:unpin-ticket").workers.add(
-        new api.ODWorker("openticket:unpin-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
-            if (originalSource != "ticket-message" && originalSource != "pin-message") return
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:unpin-ticket",/^od:unpin-ticket/))
+    opendiscord.responders.buttons.get("opendiscord:unpin-ticket").workers.add(
+        new api.ODWorker("opendiscord:unpin-ticket",0,async (instance,params,source,cancel) => {
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:unpin-ticket"]["source"],"slash"|"text">
            
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:unpin-ticket-ticket-message").activate(instance)
-            else await openticket.verifybars.get("openticket:unpin-ticket-pin-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:unpin-ticket-ticket-message").activate(instance)
+            else if (originalSource == "pin-message") await opendiscord.verifybars.get("opendiscord:unpin-ticket-pin-message").activate(instance)
+            else await instance.defer("update",false)
        })
    )
 }

 export const registerModalResponders = async () => {
    //UNPIN WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:unpin-ticket-reason",/^od:unpin-ticket-reason_/))
-    openticket.responders.modals.get("openticket:unpin-ticket-reason").workers.add([
-        new api.ODWorker("openticket:unpin-ticket-reason",0,async (instance,params,source,cancel) => {
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:unpin-ticket-reason",/^od:unpin-ticket-reason_/))
+    opendiscord.responders.modals.get("opendiscord:unpin-ticket-reason").workers.add([
+        new api.ODWorker("opendiscord:unpin-ticket-reason",0,async (instance,params,source,cancel) => {
            const {guild,channel,user} = instance
            if (!channel) return
            if (!guild){
                //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                return cancel()
            }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
            if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                return
            }

-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"pin-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:unpin-ticket"]["source"],"slash"|"text">
            const reason = instance.values.getTextField("reason",true)

            //unpin with reason
            if (originalSource == "ticket-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unpin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await opendiscord.actions.get("opendiscord:unpin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
            }else if (originalSource == "pin-message"){
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unpin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:unpin-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+                await opendiscord.actions.get("opendiscord:unpin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build("other",{guild,channel,user,ticket,reason}))
+            }else{
                await instance.defer("update",false)
-                await openticket.actions.get("openticket:unpin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:unpin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
            }
        })
    ])
@@ -16,101 +16,101 @@ import { ODRole, ODRoleUpdateMode, ODRoleUpdateResult } from "../openticket/role
 * It's used to generate typescript declarations for this class.
 */
 export interface ODActionManagerIds_Default {
-    "openticket:create-ticket-permissions":{
+    "opendiscord:create-ticket-permissions":{
        source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",
        params:{guild:discord.Guild,user:discord.User,option:ODTicketOption},
        result:{valid:boolean,reason:"blacklist"|"cooldown"|"global-limit"|"global-user-limit"|"option-limit"|"option-user-limit"|null,cooldownUntil?:Date},
-        workers:"openticket:check-blacklist"|"openticket:check-cooldown"|"openticket:check-global-limits"|"openticket:check-option-limits"|"openticket:valid"
+        workers:"opendiscord:check-blacklist"|"opendiscord:check-cooldown"|"opendiscord:check-global-limits"|"opendiscord:check-option-limits"|"opendiscord:valid"
    },
-    "openticket:create-transcript":{
+    "opendiscord:create-transcript":{
        source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},
-        result:{compiler:ODTranscriptCompiler<any>, success:boolean, result:ODTranscriptCompilerCompileResult<any>, errorReason:string|null, pendingMessage:ODMessageBuildSentResult<true>|null, participants:{user:discord.User,role:"creator"|"participant"|"admin"}[]},
-        workers:"openticket:select-compiler"|"openticket:init-transcript"|"openticket:compile-transcript"|"openticket:ready-transcript"|"openticket:logs"
+        result:{compiler:ODTranscriptCompiler<any,object|null>, success:boolean, result:ODTranscriptCompilerCompileResult<any>, errorReason:string|null, pendingMessage:ODMessageBuildSentResult<true>|null, initData:object|null, participants:{user:discord.User,role:"creator"|"participant"|"admin"}[]},
+        workers:"opendiscord:select-compiler"|"opendiscord:init-transcript"|"opendiscord:compile-transcript"|"opendiscord:ready-transcript"|"opendiscord:logs"
    },
-    "openticket:create-ticket":{
+    "opendiscord:create-ticket":{
        source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",
        params:{guild:discord.Guild,user:discord.User,option:ODTicketOption,answers:{id:string,name:string,type:"short"|"paragraph",value:string|null}[]},
        result:{channel:discord.GuildTextBasedChannel,ticket:ODTicket},
-        workers:"openticket:create-ticket"|"openticket:send-ticket-message"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:create-ticket"|"opendiscord:send-ticket-message"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:close-ticket":{
+    "opendiscord:close-ticket":{
        source:"slash"|"text"|"ticket-message"|"reopen-message"|"autoclose"|"other",
-        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean},
+        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,allowCategoryChange?:boolean},
        result:{},
-        workers:"openticket:close-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:close-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:delete-ticket":{
+    "opendiscord:delete-ticket":{
        source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,withoutTranscript:boolean},
        result:{},
-        workers:"openticket:delete-ticket"|"openticket:discord-logs"|"openticket:delete-channel"|"openticket:logs"
+        workers:"opendiscord:delete-ticket"|"opendiscord:discord-logs"|"opendiscord:delete-channel"|"opendiscord:logs"
    },
-    "openticket:reopen-ticket":{
+    "opendiscord:reopen-ticket":{
        source:"slash"|"text"|"ticket-message"|"close-message"|"autoclose-message"|"other",
-        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean},
+        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,allowCategoryChange?:boolean},
        result:{},
-        workers:"openticket:reopen-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:reopen-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:claim-ticket":{
+    "opendiscord:claim-ticket":{
        source:"slash"|"text"|"ticket-message"|"unclaim-message"|"other",
-        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean},
+        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,allowCategoryChange?:boolean},
        result:{},
-        workers:"openticket:claim-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:claim-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:unclaim-ticket":{
+    "opendiscord:unclaim-ticket":{
        source:"slash"|"text"|"ticket-message"|"claim-message"|"other",
-        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean},
+        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,allowCategoryChange?:boolean},
        result:{},
-        workers:"openticket:unclaim-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:unclaim-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:pin-ticket":{
+    "opendiscord:pin-ticket":{
        source:"slash"|"text"|"ticket-message"|"unpin-message"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean},
        result:{},
-        workers:"openticket:pin-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:pin-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:unpin-ticket":{
+    "opendiscord:unpin-ticket":{
        source:"slash"|"text"|"ticket-message"|"pin-message"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean},
        result:{},
-        workers:"openticket:unpin-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:unpin-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:rename-ticket":{
+    "opendiscord:rename-ticket":{
        source:"slash"|"text"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,data:string},
        result:{},
-        workers:"openticket:rename-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:rename-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:move-ticket":{
+    "opendiscord:move-ticket":{
        source:"slash"|"text"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,data:ODTicketOption},
        result:{},
-        workers:"openticket:move-ticket"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:move-ticket"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:add-ticket-user":{
+    "opendiscord:add-ticket-user":{
        source:"slash"|"text"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,data:discord.User},
        result:{},
-        workers:"openticket:add-ticket-user"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:add-ticket-user"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:remove-ticket-user":{
+    "opendiscord:remove-ticket-user":{
        source:"slash"|"text"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,sendMessage:boolean,data:discord.User},
        result:{},
-        workers:"openticket:remove-ticket-user"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:remove-ticket-user"|"opendiscord:discord-logs"|"opendiscord:logs"
    },
-    "openticket:reaction-role":{
+    "opendiscord:reaction-role":{
        source:"panel-button"|"other",
        params:{guild:discord.Guild,user:discord.User,option:ODRoleOption,overwriteMode:ODRoleUpdateMode|null},
        result:{result:ODRoleUpdateResult[],role:ODRole},
-        workers:"openticket:reaction-role"|"openticket:logs"
+        workers:"opendiscord:reaction-role"|"opendiscord:logs"
    },
-    "openticket:clear-tickets":{
+    "opendiscord:clear-tickets":{
        source:"slash"|"text"|"other",
        params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:ODTicket[]},
        result:{list:string[]},
-        workers:"openticket:clear-tickets"|"openticket:discord-logs"|"openticket:logs"
+        workers:"opendiscord:clear-tickets"|"opendiscord:discord-logs"|"opendiscord:logs"
    }
 }

@@ -118,7 +118,7 @@ export interface ODActionManagerIds_Default {
 * This is a special class that adds type definitions & typescript to the ODActionManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.actions`!
+ * This default class is made for the global variable `opendiscord.actions`!
 */
 export class ODActionManager_Default extends ODActionManager {
    get<ActionId extends keyof ODActionManagerIds_Default>(id:ActionId): ODAction_Default<ODActionManagerIds_Default[ActionId]["source"],ODActionManagerIds_Default[ActionId]["params"],ODActionManagerIds_Default[ActionId]["result"],ODActionManagerIds_Default[ActionId]["workers"]>
@@ -8,18 +8,18 @@ import { ODVersion, ODVersionManager, ODValidId } from "../modules/base"
 * It's used to generate typescript declarations for this class.
 */
 export interface ODVersionManagerIds_Default {
-    "openticket:version":ODVersion,
-    "openticket:last-version":ODVersion,
-    "openticket:api":ODVersion,
-    "openticket:transcripts":ODVersion,
-    "openticket:livestatus":ODVersion
+    "opendiscord:version":ODVersion,
+    "opendiscord:last-version":ODVersion,
+    "opendiscord:api":ODVersion,
+    "opendiscord:transcripts":ODVersion,
+    "opendiscord:livestatus":ODVersion
 }

 /**## ODFlagManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODFlagManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.flags`!
+ * This default class is made for the global variable `opendiscord.flags`!
 */
 export class ODVersionManager_Default extends ODVersionManager {
    get<VersionId extends keyof ODVersionManagerIds_Default>(id:VersionId): ODVersionManagerIds_Default[VersionId]
@@ -18,7 +18,7 @@ import { ODRole, ODRoleUpdateResult } from "../openticket/role"
 * This is a special class that adds type definitions & typescript to the ODBuilderManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.builders`!
+ * This default class is made for the global variable `opendiscord.builders`!
 */
 export class ODBuilderManager_Default extends ODBuilderManager {
    declare buttons: ODButtonManager_Default
@@ -34,42 +34,42 @@ export class ODBuilderManager_Default extends ODBuilderManager {
 * It's used to generate typescript declarations for this class.
 */
 export interface ODButtonManagerIds_Default {
-    "openticket:verifybar-success":{source:"verifybar"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,customData?:string,customColor?:ODValidButtonColor,customLabel?:string,customEmoji?:string},workers:"openticket:verifybar-success"},
-    "openticket:verifybar-failure":{source:"verifybar"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,customData?:string,customColor?:ODValidButtonColor,customLabel?:string,customEmoji?:string},workers:"openticket:verifybar-failure"},
+    "opendiscord:verifybar-success":{source:"verifybar"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,customData?:string,customColor?:ODValidButtonColor,customLabel?:string,customEmoji?:string},workers:"opendiscord:verifybar-success"},
+    "opendiscord:verifybar-failure":{source:"verifybar"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,customData?:string,customColor?:ODValidButtonColor,customLabel?:string,customEmoji?:string},workers:"opendiscord:verifybar-failure"},

-    "openticket:error-ticket-deprecated-transcript":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{},workers:"openticket:error-ticket-deprecated-transcript"},
+    "opendiscord:error-ticket-deprecated-transcript":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{},workers:"opendiscord:error-ticket-deprecated-transcript"},
    
-    "openticket:help-menu-previous":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"openticket:help-menu-previous"},
-    "openticket:help-menu-next":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"openticket:help-menu-next"},
-    "openticket:help-menu-page":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"openticket:help-menu-page"}
-    "openticket:help-menu-switch":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"openticket:help-menu-switch"},
+    "opendiscord:help-menu-previous":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"opendiscord:help-menu-previous"},
+    "opendiscord:help-menu-next":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"opendiscord:help-menu-next"},
+    "opendiscord:help-menu-page":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"opendiscord:help-menu-page"}
+    "opendiscord:help-menu-switch":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"opendiscord:help-menu-switch"},

-    "openticket:ticket-option":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,option:ODTicketOption},workers:"openticket:ticket-option"},
-    "openticket:website-option":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,option:ODWebsiteOption},workers:"openticket:website-option"},
-    "openticket:role-option":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,option:ODRoleOption},workers:"openticket:role-option"}
+    "opendiscord:ticket-option":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,option:ODTicketOption},workers:"opendiscord:ticket-option"},
+    "opendiscord:website-option":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,option:ODWebsiteOption},workers:"opendiscord:website-option"},
+    "opendiscord:role-option":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,option:ODRoleOption},workers:"opendiscord:role-option"}

-    "openticket:visit-ticket":{source:"ticket-created"|"dm"|"logs"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:visit-ticket"},
+    "opendiscord:visit-ticket":{source:"ticket-created"|"dm"|"logs"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:visit-ticket"},

-    "openticket:close-ticket":{source:"ticket-message"|"reopen-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:close-ticket"},
-    "openticket:delete-ticket":{source:"ticket-message"|"close-message"|"autoclose-message"|"reopen-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:delete-ticket"},
-    "openticket:reopen-ticket":{source:"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:reopen-ticket"},
-    "openticket:claim-ticket":{source:"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:claim-ticket"},
-    "openticket:unclaim-ticket":{source:"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:unclaim-ticket"},
-    "openticket:pin-ticket":{source:"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:pin-ticket"},
-    "openticket:unpin-ticket":{source:"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:unpin-ticket"},
+    "opendiscord:close-ticket":{source:"ticket-message"|"reopen-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:close-ticket"},
+    "opendiscord:delete-ticket":{source:"ticket-message"|"close-message"|"autoclose-message"|"reopen-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:delete-ticket"},
+    "opendiscord:reopen-ticket":{source:"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:reopen-ticket"},
+    "opendiscord:claim-ticket":{source:"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:claim-ticket"},
+    "opendiscord:unclaim-ticket":{source:"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:unclaim-ticket"},
+    "opendiscord:pin-ticket":{source:"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:pin-ticket"},
+    "opendiscord:unpin-ticket":{source:"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:unpin-ticket"},

-    "openticket:transcript-html-visit":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string}>,result:ODTranscriptCompilerCompileResult<{url:string}>},workers:"openticket:transcript-html-visit"},
-    "openticket:transcript-error-retry":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any>,reason:string|null},workers:"openticket:transcript-error-retry"},
-    "openticket:transcript-error-continue":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any>,reason:string|null},workers:"openticket:transcript-error-continue"},
+    "opendiscord:transcript-html-visit":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string,availableUntil:Date},{auth:string}>,result:ODTranscriptCompilerCompileResult<{url:string,availableUntil:Date}>},workers:"opendiscord:transcript-html-visit"},
+    "opendiscord:transcript-error-retry":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any,object|null>,reason:string|null},workers:"opendiscord:transcript-error-retry"},
+    "opendiscord:transcript-error-continue":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any,object|null>,reason:string|null},workers:"opendiscord:transcript-error-continue"},

-    "openticket:clear-continue":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"openticket:clear-continue"},
+    "opendiscord:clear-continue":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"opendiscord:clear-continue"},
 }

 /**## ODButtonManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODButtonManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.builders.buttons`!
+ * This default class is made for the global variable `opendiscord.builders.buttons`!
 */
 export class ODButtonManager_Default extends ODButtonManager {
    get<ButtonId extends keyof ODButtonManagerIds_Default>(id:ButtonId): ODButton_Default<ODButtonManagerIds_Default[ButtonId]["source"],ODButtonManagerIds_Default[ButtonId]["params"],ODButtonManagerIds_Default[ButtonId]["workers"]>
@@ -116,14 +116,14 @@ export class ODButton_Default<Source extends string, Params, WorkerIds extends s
 * It's used to generate typescript declarations for this class.
 */
 export interface ODDropdownManagerIds_Default {
-    "openticket:panel-dropdown-tickets":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,options:ODTicketOption[]},workers:"openticket:panel-dropdown-tickets"}
+    "opendiscord:panel-dropdown-tickets":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel,options:ODTicketOption[]},workers:"opendiscord:panel-dropdown-tickets"}
 }

 /**## ODDropdownManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODDropdownManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.builders.dropdowns`!
+ * This default class is made for the global variable `opendiscord.builders.dropdowns`!
 */
 export class ODDropdownManager_Default extends ODDropdownManager {
    get<DropdownId extends keyof ODDropdownManagerIds_Default>(id:DropdownId): ODDropdown_Default<ODDropdownManagerIds_Default[DropdownId]["source"],ODDropdownManagerIds_Default[DropdownId]["params"],ODDropdownManagerIds_Default[DropdownId]["workers"]>
@@ -170,14 +170,14 @@ export class ODDropdown_Default<Source extends string, Params, WorkerIds extends
 * It's used to generate typescript declarations for this class.
 */
 export interface ODFileManagerIds_Default {
-    "openticket:text-transcript":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any>,result:ODTranscriptCompilerCompileResult<any>},workers:"openticket:text-transcript"}
+    "opendiscord:text-transcript":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any,object|null>,result:ODTranscriptCompilerCompileResult<any>},workers:"opendiscord:text-transcript"}
 }

 /**## ODFileManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODFileManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.builders.files`!
+ * This default class is made for the global variable `opendiscord.builders.files`!
 */
 export class ODFileManager_Default extends ODFileManager {
    get<FileId extends keyof ODFileManagerIds_Default>(id:FileId): ODFile_Default<ODFileManagerIds_Default[FileId]["source"],ODFileManagerIds_Default[FileId]["params"],ODFileManagerIds_Default[FileId]["workers"]>
@@ -224,80 +224,80 @@ export class ODFile_Default<Source extends string, Params, WorkerIds extends str
 * It's used to generate typescript declarations for this class.
 */
 export interface ODEmbedManagerIds_Default {
-    "openticket:error":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:string,layout:"simple"|"advanced"},workers:"openticket:error"},
-    "openticket:error-option-missing":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorMissingOption},workers:"openticket:error-option-missing"},
-    "openticket:error-option-invalid":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorInvalidOption},workers:"openticket:error-option-invalid"},
-    "openticket:error-unknown-command":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorUnknownCommand},workers:"openticket:error-unknown-command"},
-    "openticket:error-no-permissions":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,permissions:ODPermissionEmbedType[]},workers:"openticket:error-no-permissions"},
-    "openticket:error-no-permissions-cooldown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,until?:Date},workers:"openticket:error-no-permissions-cooldown"},
-    "openticket:error-no-permissions-blacklisted":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-no-permissions-blacklisted"},
-    "openticket:error-no-permissions-limits":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,limit:"global"|"global-user"|"option"|"option-user"},workers:"openticket:error-no-permissions-limits"},
-    "openticket:error-responder-timeout":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-responder-timeout"},
-    "openticket:error-ticket-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-ticket-unknown"},
-    "openticket:error-ticket-deprecated":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-ticket-deprecated"},
-    "openticket:error-option-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-option-unknown"},
-    "openticket:error-panel-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-panel-unknown"},
-    "openticket:error-not-in-guild":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-not-in-guild"},
-    "openticket:error-channel-rename":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"ticket-pin"|"ticket-unpin"|"ticket-rename"|"ticket-move"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,originalName:string,newName:string},workers:"openticket:error-channel-rename"},
-    "openticket:error-ticket-busy":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-ticket-busy"},
+    "opendiscord:error":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:string,layout:"simple"|"advanced"},workers:"opendiscord:error"},
+    "opendiscord:error-option-missing":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorMissingOption},workers:"opendiscord:error-option-missing"},
+    "opendiscord:error-option-invalid":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorInvalidOption},workers:"opendiscord:error-option-invalid"},
+    "opendiscord:error-unknown-command":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorUnknownCommand},workers:"opendiscord:error-unknown-command"},
+    "opendiscord:error-no-permissions":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,permissions:ODPermissionEmbedType[]},workers:"opendiscord:error-no-permissions"},
+    "opendiscord:error-no-permissions-cooldown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,until?:Date},workers:"opendiscord:error-no-permissions-cooldown"},
+    "opendiscord:error-no-permissions-blacklisted":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-no-permissions-blacklisted"},
+    "opendiscord:error-no-permissions-limits":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,limit:"global"|"global-user"|"option"|"option-user"},workers:"opendiscord:error-no-permissions-limits"},
+    "opendiscord:error-responder-timeout":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-responder-timeout"},
+    "opendiscord:error-ticket-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-ticket-unknown"},
+    "opendiscord:error-ticket-deprecated":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-ticket-deprecated"},
+    "opendiscord:error-option-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-option-unknown"},
+    "opendiscord:error-panel-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-panel-unknown"},
+    "opendiscord:error-not-in-guild":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-not-in-guild"},
+    "opendiscord:error-channel-rename":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"ticket-pin"|"ticket-unpin"|"ticket-rename"|"ticket-move"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,originalName:string,newName:string},workers:"opendiscord:error-channel-rename"},
+    "opendiscord:error-ticket-busy":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-ticket-busy"},

-    "openticket:help-menu":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"openticket:help-menu"},
+    "opendiscord:help-menu":{source:"text"|"slash"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"opendiscord:help-menu"},
    
-    "openticket:stats-global":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:stats-global"},
-    "openticket:stats-ticket":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:ODTicket},workers:"openticket:stats-ticket"},
-    "openticket:stats-user":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:discord.User},workers:"openticket:stats-user"|"openticket:easter-egg"},
-    "openticket:stats-reset":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,reason:string|null},workers:"openticket:stats-reset"},
-    "openticket:stats-ticket-unknown":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,id:string},workers:"openticket:stats-ticket-unknown"},
+    "opendiscord:stats-global":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:stats-global"},
+    "opendiscord:stats-ticket":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:ODTicket},workers:"opendiscord:stats-ticket"},
+    "opendiscord:stats-user":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:discord.User},workers:"opendiscord:stats-user"|"opendiscord:easter-egg"},
+    "opendiscord:stats-reset":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,reason:string|null},workers:"opendiscord:stats-reset"},
+    "opendiscord:stats-ticket-unknown":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,id:string},workers:"opendiscord:stats-ticket-unknown"},
    
-    "openticket:panel":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel},workers:"openticket:panel"},
-    "openticket:ticket-created":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-created"},
-    "openticket:ticket-created-dm":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-created-dm"},
-    "openticket:ticket-created-logs":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-created-logs"},
-    "openticket:ticket-message":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-message"},
-    "openticket:close-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"autoclose"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:close-message"},
-    "openticket:reopen-message":{source:"slash"|"text"|"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:reopen-message"},
-    "openticket:delete-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:delete-message"},
-    "openticket:claim-message":{source:"slash"|"text"|"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:claim-message"},
-    "openticket:unclaim-message":{source:"slash"|"text"|"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:unclaim-message"},
-    "openticket:pin-message":{source:"slash"|"text"|"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:pin-message"},
-    "openticket:unpin-message":{source:"slash"|"text"|"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:unpin-message"},
-    "openticket:rename-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:string},workers:"openticket:rename-message"},
-    "openticket:move-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:ODTicketOption},workers:"openticket:move-message"},
-    "openticket:add-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"openticket:add-message"},
-    "openticket:remove-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"openticket:remove-message"},
-    "openticket:ticket-action-dm":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"openticket:ticket-action-dm"},
-    "openticket:ticket-action-logs":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"openticket:ticket-action-logs"},
+    "opendiscord:panel":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel},workers:"opendiscord:panel"},
+    "opendiscord:ticket-created":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-created"},
+    "opendiscord:ticket-created-dm":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-created-dm"},
+    "opendiscord:ticket-created-logs":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-created-logs"},
+    "opendiscord:ticket-message":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-message"},
+    "opendiscord:close-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"autoclose"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:close-message"},
+    "opendiscord:reopen-message":{source:"slash"|"text"|"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:reopen-message"},
+    "opendiscord:delete-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:delete-message"},
+    "opendiscord:claim-message":{source:"slash"|"text"|"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:claim-message"},
+    "opendiscord:unclaim-message":{source:"slash"|"text"|"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:unclaim-message"},
+    "opendiscord:pin-message":{source:"slash"|"text"|"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:pin-message"},
+    "opendiscord:unpin-message":{source:"slash"|"text"|"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:unpin-message"},
+    "opendiscord:rename-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:string},workers:"opendiscord:rename-message"},
+    "opendiscord:move-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:ODTicketOption},workers:"opendiscord:move-message"},
+    "opendiscord:add-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"opendiscord:add-message"},
+    "opendiscord:remove-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"opendiscord:remove-message"},
+    "opendiscord:ticket-action-dm":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"opendiscord:ticket-action-dm"},
+    "opendiscord:ticket-action-logs":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"opendiscord:ticket-action-logs"},

-    "openticket:blacklist-view":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:blacklist-view"},
-    "openticket:blacklist-get":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User},workers:"openticket:blacklist-get"},
-    "openticket:blacklist-add":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"openticket:blacklist-add"},
-    "openticket:blacklist-remove":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"openticket:blacklist-remove"}
-    "openticket:blacklist-dm":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"openticket:blacklist-dm"},
-    "openticket:blacklist-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"openticket:blacklist-logs"},
+    "opendiscord:blacklist-view":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:blacklist-view"},
+    "opendiscord:blacklist-get":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User},workers:"opendiscord:blacklist-get"},
+    "opendiscord:blacklist-add":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"opendiscord:blacklist-add"},
+    "opendiscord:blacklist-remove":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"opendiscord:blacklist-remove"}
+    "opendiscord:blacklist-dm":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"opendiscord:blacklist-dm"},
+    "opendiscord:blacklist-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"opendiscord:blacklist-logs"},

-    "openticket:transcript-text-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{contents:string}>,result:ODTranscriptCompilerCompileResult<{contents:string}>},workers:"openticket:transcript-text-ready"},
-    "openticket:transcript-html-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string}>,result:ODTranscriptCompilerCompileResult<{url:string}>},workers:"openticket:transcript-html-ready"},
-    "openticket:transcript-html-progress":{source:"channel"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string}>,remaining:number},workers:"openticket:transcript-html-progress"},
-    "openticket:transcript-error":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any>,reason:string|null},workers:"openticket:transcript-error"},
+    "opendiscord:transcript-text-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{contents:string},null>,result:ODTranscriptCompilerCompileResult<{contents:string}>},workers:"opendiscord:transcript-text-ready"},
+    "opendiscord:transcript-html-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string,availableUntil:Date},{auth:string}>,result:ODTranscriptCompilerCompileResult<{url:string,availableUntil:Date}>},workers:"opendiscord:transcript-html-ready"},
+    "opendiscord:transcript-html-progress":{source:"channel"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string,availableUntil:Date},{auth:string}>,remaining:number},workers:"opendiscord:transcript-html-progress"},
+    "opendiscord:transcript-error":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any,object|null>,reason:string|null},workers:"opendiscord:transcript-error"},

-    "openticket:reaction-role":{source:"panel-button"|"other",params:{guild:discord.Guild,user:discord.User,role:ODRole,result:ODRoleUpdateResult[]},workers:"openticket:reaction-role"},
-    "openticket:clear-verify-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"openticket:clear-verify-message"},
-    "openticket:clear-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"openticket:clear-message"},
-    "openticket:clear-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"openticket:clear-logs"},
+    "opendiscord:reaction-role":{source:"panel-button"|"other",params:{guild:discord.Guild,user:discord.User,role:ODRole,result:ODRoleUpdateResult[]},workers:"opendiscord:reaction-role"},
+    "opendiscord:clear-verify-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"opendiscord:clear-verify-message"},
+    "opendiscord:clear-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"opendiscord:clear-message"},
+    "opendiscord:clear-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"opendiscord:clear-logs"},

-    "openticket:autoclose-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:autoclose-message"},
-    "openticket:autodelete-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:autodelete-message"},
-    "openticket:autoclose-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"openticket:autoclose-enable"},
-    "openticket:autodelete-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"openticket:autodelete-enable"},
-    "openticket:autoclose-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:autoclose-disable"},
-    "openticket:autodelete-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:autodelete-disable"},
+    "opendiscord:autoclose-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:autoclose-message"},
+    "opendiscord:autodelete-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:autodelete-message"},
+    "opendiscord:autoclose-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"opendiscord:autoclose-enable"},
+    "opendiscord:autodelete-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"opendiscord:autodelete-enable"},
+    "opendiscord:autoclose-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:autoclose-disable"},
+    "opendiscord:autodelete-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:autodelete-disable"},
 }

 /**## ODEmbedManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODEmbedManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.builders.embeds`!
+ * This default class is made for the global variable `opendiscord.builders.embeds`!
 */
 export class ODEmbedManager_Default extends ODEmbedManager {
    get<EmbedId extends keyof ODEmbedManagerIds_Default>(id:EmbedId): ODEmbed_Default<ODEmbedManagerIds_Default[EmbedId]["source"],ODEmbedManagerIds_Default[EmbedId]["params"],ODEmbedManagerIds_Default[EmbedId]["workers"]>
@@ -344,91 +344,91 @@ export class ODEmbed_Default<Source extends string, Params, WorkerIds extends st
 * It's used to generate typescript declarations for this class.
 */
 export interface ODMessageManagerIds_Default {
-    "openticket:verifybar-ticket-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-ticket-message"},
-    "openticket:verifybar-close-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-close-message"},
-    "openticket:verifybar-reopen-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-reopen-message"},
-    "openticket:verifybar-claim-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-claim-message"},
-    "openticket:verifybar-unclaim-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-unclaim-message"},
-    "openticket:verifybar-pin-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-pin-message"},
-    "openticket:verifybar-unpin-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-unpin-message"}
-    "openticket:verifybar-autoclose-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"openticket:verifybar-autoclose-message"}
+    "opendiscord:verifybar-ticket-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-ticket-message"},
+    "opendiscord:verifybar-close-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-close-message"},
+    "opendiscord:verifybar-reopen-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-reopen-message"},
+    "opendiscord:verifybar-claim-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-claim-message"},
+    "opendiscord:verifybar-unclaim-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-unclaim-message"},
+    "opendiscord:verifybar-pin-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-pin-message"},
+    "opendiscord:verifybar-unpin-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-unpin-message"}
+    "opendiscord:verifybar-autoclose-message":{source:"verifybar",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>},workers:"opendiscord:verifybar-autoclose-message"}
    
-    "openticket:error":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:string,layout:"simple"|"advanced"},workers:"openticket:error"},
-    "openticket:error-option-missing":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorMissingOption},workers:"openticket:error-option-missing"},
-    "openticket:error-option-invalid":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorInvalidOption},workers:"openticket:error-option-invalid"},
-    "openticket:error-unknown-command":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorUnknownCommand},workers:"openticket:error-unknown-command"},
-    "openticket:error-no-permissions":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,permissions:ODPermissionEmbedType[]},workers:"openticket:error-no-permissions"},
-    "openticket:error-no-permissions-cooldown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,until?:Date},workers:"openticket:error-no-permissions-cooldown"},
-    "openticket:error-no-permissions-blacklisted":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-no-permissions-blacklisted"},
-    "openticket:error-no-permissions-limits":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,limit:"global"|"global-user"|"option"|"option-user"},workers:"openticket:error-no-permissions-limits"},
-    "openticket:error-responder-timeout":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-responder-timeout"},
-    "openticket:error-ticket-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-ticket-unknown"},
-    "openticket:error-ticket-deprecated":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-ticket-deprecated"},
-    "openticket:error-option-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-option-unknown"},
-    "openticket:error-panel-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-panel-unknown"},
-    "openticket:error-not-in-guild":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-not-in-guild"},
-    "openticket:error-channel-rename":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"ticket-pin"|"ticket-unpin"|"ticket-rename"|"ticket-move"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,originalName:string,newName:string},workers:"openticket:error-channel-rename"},
-    "openticket:error-ticket-busy":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:error-ticket-busy"},
+    "opendiscord:error":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:string,layout:"simple"|"advanced"},workers:"opendiscord:error"},
+    "opendiscord:error-option-missing":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorMissingOption},workers:"opendiscord:error-option-missing"},
+    "opendiscord:error-option-invalid":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorInvalidOption},workers:"opendiscord:error-option-invalid"},
+    "opendiscord:error-unknown-command":{source:"slash"|"text"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,error:ODTextCommandErrorUnknownCommand},workers:"opendiscord:error-unknown-command"},
+    "opendiscord:error-no-permissions":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,permissions:ODPermissionEmbedType[]},workers:"opendiscord:error-no-permissions"},
+    "opendiscord:error-no-permissions-cooldown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,until?:Date},workers:"opendiscord:error-no-permissions-cooldown"},
+    "opendiscord:error-no-permissions-blacklisted":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-no-permissions-blacklisted"},
+    "opendiscord:error-no-permissions-limits":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,limit:"global"|"global-user"|"option"|"option-user"},workers:"opendiscord:error-no-permissions-limits"},
+    "opendiscord:error-responder-timeout":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-responder-timeout"},
+    "opendiscord:error-ticket-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-ticket-unknown"},
+    "opendiscord:error-ticket-deprecated":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-ticket-deprecated"},
+    "opendiscord:error-option-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-option-unknown"},
+    "opendiscord:error-panel-unknown":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-panel-unknown"},
+    "opendiscord:error-not-in-guild":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-not-in-guild"},
+    "opendiscord:error-channel-rename":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"ticket-pin"|"ticket-unpin"|"ticket-rename"|"ticket-move"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,originalName:string,newName:string},workers:"opendiscord:error-channel-rename"},
+    "opendiscord:error-ticket-busy":{source:"slash"|"text"|"button"|"dropdown"|"modal"|"other",params:{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:error-ticket-busy"},
    
-    "openticket:help-menu":{source:"slash"|"text"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"openticket:help-menu"},
+    "opendiscord:help-menu":{source:"slash"|"text"|"button"|"other",params:{mode:"slash"|"text",page:number},workers:"opendiscord:help-menu"},
    
-    "openticket:stats-global":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:stats-global"},
-    "openticket:stats-ticket":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:ODTicket},workers:"openticket:stats-ticket"},
-    "openticket:stats-user":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:discord.User},workers:"openticket:stats-user"|"openticket:easter-egg"},
-    "openticket:stats-reset":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,reason:string|null},workers:"openticket:stats-reset"},
-    "openticket:stats-ticket-unknown":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,id:string},workers:"openticket:stats-ticket-unknown"},
+    "opendiscord:stats-global":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:stats-global"},
+    "opendiscord:stats-ticket":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:ODTicket},workers:"opendiscord:stats-ticket"},
+    "opendiscord:stats-user":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,scopeData:discord.User},workers:"opendiscord:stats-user"|"opendiscord:easter-egg"},
+    "opendiscord:stats-reset":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,reason:string|null},workers:"opendiscord:stats-reset"},
+    "opendiscord:stats-ticket-unknown":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,id:string},workers:"opendiscord:stats-ticket-unknown"},
    
-    "openticket:panel":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel},workers:"openticket:panel-layout"|"openticket:panel-components"},
-    "openticket:panel-ready":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel},workers:"openticket:panel-ready"},
+    "opendiscord:panel":{source:"slash"|"text"|"auto-update"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel},workers:"opendiscord:panel-layout"|"opendiscord:panel-components"},
+    "opendiscord:panel-ready":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,panel:ODPanel},workers:"opendiscord:panel-ready"},
    
-    "openticket:ticket-created":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-created"},
-    "openticket:ticket-created-dm":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-created-dm"},
-    "openticket:ticket-created-logs":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-created-logs"},
-    "openticket:ticket-message":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:ticket-message-layout"|"openticket:ticket-message-components"|"openticket:ticket-message-disable-components"},
-    "openticket:close-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"autoclose"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:close-message"},
-    "openticket:reopen-message":{source:"slash"|"text"|"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:reopen-message"},
-    "openticket:delete-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:delete-message"},
-    "openticket:claim-message":{source:"slash"|"text"|"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:claim-message"},
-    "openticket:unclaim-message":{source:"slash"|"text"|"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:unclaim-message"},
-    "openticket:pin-message":{source:"slash"|"text"|"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:pin-message"},
-    "openticket:unpin-message":{source:"slash"|"text"|"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:unpin-message"},
-    "openticket:rename-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:string},workers:"openticket:rename-message"},
-    "openticket:move-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:ODTicketOption},workers:"openticket:move-message"},
-    "openticket:add-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"openticket:add-message"},
-    "openticket:remove-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"openticket:remove-message"},
-    "openticket:ticket-action-dm":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"openticket:ticket-action-dm"},
-    "openticket:ticket-action-logs":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"openticket:ticket-action-logs"},
+    "opendiscord:ticket-created":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-created"},
+    "opendiscord:ticket-created-dm":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-created-dm"},
+    "opendiscord:ticket-created-logs":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-created-logs"},
+    "opendiscord:ticket-message":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:ticket-message-layout"|"opendiscord:ticket-message-components"|"opendiscord:ticket-message-disable-components"},
+    "opendiscord:close-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"autoclose"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:close-message"},
+    "opendiscord:reopen-message":{source:"slash"|"text"|"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:reopen-message"},
+    "opendiscord:delete-message":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:delete-message"},
+    "opendiscord:claim-message":{source:"slash"|"text"|"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:claim-message"},
+    "opendiscord:unclaim-message":{source:"slash"|"text"|"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:unclaim-message"},
+    "opendiscord:pin-message":{source:"slash"|"text"|"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:pin-message"},
+    "opendiscord:unpin-message":{source:"slash"|"text"|"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:unpin-message"},
+    "opendiscord:rename-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:string},workers:"opendiscord:rename-message"},
+    "opendiscord:move-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:ODTicketOption},workers:"opendiscord:move-message"},
+    "opendiscord:add-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"opendiscord:add-message"},
+    "opendiscord:remove-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null,data:discord.User},workers:"opendiscord:remove-message"},
+    "opendiscord:ticket-action-dm":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"opendiscord:ticket-action-dm"},
+    "opendiscord:ticket-action-logs":{source:"slash"|"text"|"ticket-message"|"close-message"|"reopen-message"|"delete-message"|"claim-message"|"unclaim-message"|"pin-message"|"unpin-message"|"autoclose-message"|"autoclose"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"close"|"reopen"|"delete"|"claim"|"unclaim"|"pin"|"unpin"|"rename"|"move"|"add"|"remove",ticket:ODTicket,reason:string|null,additionalData:null|string|discord.User|ODTicketOption},workers:"opendiscord:ticket-action-logs"},
    
-    "openticket:blacklist-view":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"openticket:blacklist-view"},
-    "openticket:blacklist-get":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User},workers:"openticket:blacklist-get"},
-    "openticket:blacklist-add":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"openticket:blacklist-add"},
-    "openticket:blacklist-remove":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"openticket:blacklist-remove"},
-    "openticket:blacklist-dm":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"openticket:blacklist-dm"},
-    "openticket:blacklist-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"openticket:blacklist-logs"},
+    "opendiscord:blacklist-view":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User},workers:"opendiscord:blacklist-view"},
+    "opendiscord:blacklist-get":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User},workers:"opendiscord:blacklist-get"},
+    "opendiscord:blacklist-add":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"opendiscord:blacklist-add"},
+    "opendiscord:blacklist-remove":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,data:discord.User,reason:string|null},workers:"opendiscord:blacklist-remove"},
+    "opendiscord:blacklist-dm":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"opendiscord:blacklist-dm"},
+    "opendiscord:blacklist-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,mode:"add"|"remove",data:discord.User,reason:string|null},workers:"opendiscord:blacklist-logs"},

-    "openticket:transcript-text-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{contents:string}>,result:ODTranscriptCompilerCompileResult<{contents:string}>},workers:"openticket:transcript-text-ready"},
-    "openticket:transcript-html-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string}>,result:ODTranscriptCompilerCompileResult<{url:string}>},workers:"openticket:transcript-html-ready"},
-    "openticket:transcript-html-progress":{source:"channel"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string}>,remaining:number},workers:"openticket:transcript-html-progress"},
-    "openticket:transcript-error":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any>,reason:string|null},workers:"openticket:transcript-error"},
+    "opendiscord:transcript-text-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{contents:string},null>,result:ODTranscriptCompilerCompileResult<{contents:string}>},workers:"opendiscord:transcript-text-ready"},
+    "opendiscord:transcript-html-ready":{source:"channel"|"creator-dm"|"participant-dm"|"active-admin-dm"|"every-admin-dm"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string,availableUntil:Date},{auth:string}>,result:ODTranscriptCompilerCompileResult<{url:string,availableUntil:Date}>},workers:"opendiscord:transcript-html-ready"},
+    "opendiscord:transcript-html-progress":{source:"channel"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<{url:string,availableUntil:Date},{auth:string}>,remaining:number},workers:"opendiscord:transcript-html-progress"},
+    "opendiscord:transcript-error":{source:"slash"|"text"|"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"autodelete"|"clear"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,compiler:ODTranscriptCompiler<any,object|null>,reason:string|null},workers:"opendiscord:transcript-error"},

-    "openticket:reaction-role":{source:"panel-button"|"other",params:{guild:discord.Guild,user:discord.User,role:ODRole,result:ODRoleUpdateResult[]},workers:"openticket:reaction-role"},
-    "openticket:clear-verify-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"openticket:clear-verify-message"},
-    "openticket:clear-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"openticket:clear-message"},
-    "openticket:clear-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"openticket:clear-logs"},
+    "opendiscord:reaction-role":{source:"panel-button"|"other",params:{guild:discord.Guild,user:discord.User,role:ODRole,result:ODRoleUpdateResult[]},workers:"opendiscord:reaction-role"},
+    "opendiscord:clear-verify-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"opendiscord:clear-verify-message"},
+    "opendiscord:clear-message":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"opendiscord:clear-message"},
+    "opendiscord:clear-logs":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,filter:ODTicketClearFilter,list:string[]},workers:"opendiscord:clear-logs"},

-    "openticket:autoclose-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:autoclose-message"},
-    "openticket:autodelete-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:autodelete-message"},
-    "openticket:autoclose-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"openticket:autoclose-enable"},
-    "openticket:autodelete-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"openticket:autodelete-enable"},
-    "openticket:autoclose-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:autoclose-disable"},
-    "openticket:autodelete-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"openticket:autodelete-disable"},
+    "opendiscord:autoclose-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:autoclose-message"},
+    "opendiscord:autodelete-message":{source:"timeout"|"leave"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:autodelete-message"},
+    "opendiscord:autoclose-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"opendiscord:autoclose-enable"},
+    "opendiscord:autodelete-enable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,time:number,reason:string|null},workers:"opendiscord:autodelete-enable"},
+    "opendiscord:autoclose-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:autoclose-disable"},
+    "opendiscord:autodelete-disable":{source:"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.GuildTextBasedChannel,user:discord.User,ticket:ODTicket,reason:string|null},workers:"opendiscord:autodelete-disable"},
 }

 /**## ODMessageManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODMessageManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.builders.messages`!
+ * This default class is made for the global variable `opendiscord.builders.messages`!
 */
 export class ODMessageManager_Default extends ODMessageManager {
    get<MessageId extends keyof ODMessageManagerIds_Default>(id:MessageId): ODMessage_Default<ODMessageManagerIds_Default[MessageId]["source"],ODMessageManagerIds_Default[MessageId]["params"],ODMessageManagerIds_Default[MessageId]["workers"]>
@@ -475,21 +475,21 @@ export class ODMessage_Default<Source extends string, Params, WorkerIds extends
 * It's used to generate typescript declarations for this class.
 */
 export interface ODModalManagerIds_Default {
-    "openticket:ticket-questions":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,option:ODTicketOption},workers:"openticket:ticket-questions"}
-    "openticket:close-ticket-reason":{source:"ticket-message"|"reopen-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:close-ticket-reason"}
-    "openticket:reopen-ticket-reason":{source:"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:reopen-ticket-reason"}
-    "openticket:delete-ticket-reason":{source:"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:delete-ticket-reason"}
-    "openticket:claim-ticket-reason":{source:"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:claim-ticket-reason"}
-    "openticket:unclaim-ticket-reason":{source:"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:unclaim-ticket-reason"}
-    "openticket:pin-ticket-reason":{source:"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:pin-ticket-reason"}
-    "openticket:unpin-ticket-reason":{source:"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"openticket:unpin-ticket-reason"}
+    "opendiscord:ticket-questions":{source:"panel-button"|"panel-dropdown"|"slash"|"text"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,option:ODTicketOption},workers:"opendiscord:ticket-questions"}
+    "opendiscord:close-ticket-reason":{source:"ticket-message"|"reopen-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:close-ticket-reason"}
+    "opendiscord:reopen-ticket-reason":{source:"ticket-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:reopen-ticket-reason"}
+    "opendiscord:delete-ticket-reason":{source:"ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:delete-ticket-reason"}
+    "opendiscord:claim-ticket-reason":{source:"ticket-message"|"unclaim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:claim-ticket-reason"}
+    "opendiscord:unclaim-ticket-reason":{source:"ticket-message"|"claim-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:unclaim-ticket-reason"}
+    "opendiscord:pin-ticket-reason":{source:"ticket-message"|"unpin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:pin-ticket-reason"}
+    "opendiscord:unpin-ticket-reason":{source:"ticket-message"|"pin-message"|"other",params:{guild:discord.Guild,channel:discord.TextBasedChannel,user:discord.User,ticket:ODTicket},workers:"opendiscord:unpin-ticket-reason"}
 }

 /**## ODModalManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODModalManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.builders.modals`!
+ * This default class is made for the global variable `opendiscord.builders.modals`!
 */
 export class ODModalManager_Default extends ODModalManager {
    get<ModalId extends keyof ODModalManagerIds_Default>(id:ModalId): ODModal_Default<ODModalManagerIds_Default[ModalId]["source"],ODModalManagerIds_Default[ModalId]["params"],ODModalManagerIds_Default[ModalId]["workers"]>
@@ -11,18 +11,18 @@ import ansis from "ansis"
 * It's used to generate typescript declarations for this class.
 */
 export interface ODCheckerManagerIds_Default {
-    "openticket:general":ODChecker,
-    "openticket:questions":ODChecker,
-    "openticket:options":ODChecker,
-    "openticket:panels":ODChecker,
-    "openticket:transcripts":ODChecker
+    "opendiscord:general":ODChecker,
+    "opendiscord:questions":ODChecker,
+    "opendiscord:options":ODChecker,
+    "opendiscord:panels":ODChecker,
+    "opendiscord:transcripts":ODChecker
 }

 /**## ODCheckerManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODCheckerManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.checkers`!
+ * This default class is made for the global variable `opendiscord.checkers`!
 */
 export class ODCheckerManager_Default extends ODCheckerManager {
    declare translation: ODCheckerTranslationRegister_Default
@@ -55,7 +55,7 @@ export class ODCheckerManager_Default extends ODCheckerManager {
 * This is a special class that adds type definitions & features to the ODCheckerRenderer class.
 * It contains the code that renders the default config checker.
 * 
- * This default class is made for the global variable `openticket.checkers.renderer`!
+ * This default class is made for the global variable `opendiscord.checkers.renderer`!
 */
 export class ODCheckerRenderer_Default extends ODCheckerRenderer {
    extraHeaderText: string[] = []
@@ -75,19 +75,19 @@ export class ODCheckerRenderer_Default extends ODCheckerRenderer {
    getComponents(compact:boolean, renderEmpty:boolean, translation:ODCheckerTranslationRegister_Default, data:ODCheckerResult): string[] {
        const tm = translation
        const t = {
-            headerOpenticket:tm.get("other","openticket:header-openticket") ?? "OPEN TICKET",
-            headerConfigchecker:tm.get("other","openticket:header-configchecker") ?? "CONFIG CHECKER",
-            headerDescription:tm.get("other","openticket:header-description") ?? "check for errors in your config files!",
-            footerError:tm.get("other","openticket:footer-error") ?? "the bot won't start until all {0}'s are fixed!",
-            footerWarning:tm.get("other","openticket:footer-warning") ?? "it's recommended to fix all {0}'s before starting!",
-            footerSupport:tm.get("other","openticket:footer-support") ?? "SUPPORT: {0} - DOCS: {1}",
-            error:tm.get("other","openticket:type-error") ?? "[ERROR]",
-            warning:tm.get("other","openticket:type-warning") ?? "[WARNING]",
-            info:tm.get("other","openticket:type-info") ?? "[INFO]",
-            compactInfo:tm.get("other","openticket:compact-information") ?? "use {0} for more information!",
-            dataPath:tm.get("other","openticket:data-path") ?? "path",
-            dataDocs:tm.get("other","openticket:data-docs") ?? "docs",
-            dataMessage:tm.get("other","openticket:data-message") ?? "message"
+            headerOpenticket:tm.get("other","opendiscord:header-openticket") ?? "OPEN TICKET",
+            headerConfigchecker:tm.get("other","opendiscord:header-configchecker") ?? "CONFIG CHECKER",
+            headerDescription:tm.get("other","opendiscord:header-description") ?? "check for errors in your config files!",
+            footerError:tm.get("other","opendiscord:footer-error") ?? "the bot won't start until all {0}'s are fixed!",
+            footerWarning:tm.get("other","opendiscord:footer-warning") ?? "it's recommended to fix all {0}'s before starting!",
+            footerSupport:tm.get("other","opendiscord:footer-support") ?? "SUPPORT: {0} - DOCS: {1}",
+            error:tm.get("other","opendiscord:type-error") ?? "[ERROR]",
+            warning:tm.get("other","opendiscord:type-warning") ?? "[WARNING]",
+            info:tm.get("other","opendiscord:type-info") ?? "[INFO]",
+            compactInfo:tm.get("other","opendiscord:compact-information") ?? "use {0} for more information!",
+            dataPath:tm.get("other","opendiscord:data-path") ?? "path",
+            dataDocs:tm.get("other","opendiscord:data-docs") ?? "docs",
+            dataMessage:tm.get("other","opendiscord:data-message") ?? "message"
        }
        const hasErrors = data.messages.filter((m) => m.type == "error").length > 0
        const hasWarnings = data.messages.filter((m) => m.type == "warning").length > 0
@@ -213,19 +213,19 @@ export class ODCheckerRenderer_Default extends ODCheckerRenderer {
 * It's used to generate typescript declarations for this class.
 */
 export type ODCheckerTranslationRegisterOtherIds_Default = (
-    "openticket:header-openticket"|
-    "openticket:header-configchecker"|
-    "openticket:header-description"|
-    "openticket:type-error"|
-    "openticket:type-warning"|
-    "openticket:type-info"|
-    "openticket:data-path"|
-    "openticket:data-docs"|
-    "openticket:data-message"|
-    "openticket:compact-information"|
-    "openticket:footer-error"|
-    "openticket:footer-warning"|
-    "openticket:footer-support"
+    "opendiscord:header-openticket"|
+    "opendiscord:header-configchecker"|
+    "opendiscord:header-description"|
+    "opendiscord:type-error"|
+    "opendiscord:type-warning"|
+    "opendiscord:type-info"|
+    "opendiscord:data-path"|
+    "opendiscord:data-docs"|
+    "opendiscord:data-message"|
+    "opendiscord:compact-information"|
+    "opendiscord:footer-error"|
+    "opendiscord:footer-warning"|
+    "opendiscord:footer-support"
 )

 /**## ODCheckerTranslationRegisterMessageIds_Default `interface`
@@ -233,80 +233,80 @@ export type ODCheckerTranslationRegisterOtherIds_Default = (
 * It's used to generate typescript declarations for this class.
 */
 export type ODCheckerTranslationRegisterMessageIds_Default = (
-    "openticket:invalid-type"|
-    "openticket:property-missing"|
-    "openticket:property-optional"|
-    "openticket:object-disabled"|
-    "openticket:null-invalid"|
-    "openticket:switch-invalid-type"|
-    "openticket:object-switch-invalid-type"|
+    "opendiscord:invalid-type"|
+    "opendiscord:property-missing"|
+    "opendiscord:property-optional"|
+    "opendiscord:object-disabled"|
+    "opendiscord:null-invalid"|
+    "opendiscord:switch-invalid-type"|
+    "opendiscord:object-switch-invalid-type"|

-    "openticket:string-too-short"|
-    "openticket:string-too-long"|
-    "openticket:string-length-invalid"|
-    "openticket:string-starts-with"|
-    "openticket:string-ends-with"|
-    "openticket:string-contains"|
-    "openticket:string-choices"|
-    "openticket:string-regex"|
+    "opendiscord:string-too-short"|
+    "opendiscord:string-too-long"|
+    "opendiscord:string-length-invalid"|
+    "opendiscord:string-starts-with"|
+    "opendiscord:string-ends-with"|
+    "opendiscord:string-contains"|
+    "opendiscord:string-choices"|
+    "opendiscord:string-regex"|

-    "openticket:number-too-short"|
-    "openticket:number-too-long"|
-    "openticket:number-length-invalid"|
-    "openticket:number-too-small"|
-    "openticket:number-too-large"|
-    "openticket:number-not-equal"|
-    "openticket:number-step"|
-    "openticket:number-step-offset"|
-    "openticket:number-starts-with"|
-    "openticket:number-ends-with"|
-    "openticket:number-contains"|
-    "openticket:number-choices"|
-    "openticket:number-float"|
-    "openticket:number-negative"|
-    "openticket:number-positive"|
-    "openticket:number-zero"|
+    "opendiscord:number-too-short"|
+    "opendiscord:number-too-long"|
+    "opendiscord:number-length-invalid"|
+    "opendiscord:number-too-small"|
+    "opendiscord:number-too-large"|
+    "opendiscord:number-not-equal"|
+    "opendiscord:number-step"|
+    "opendiscord:number-step-offset"|
+    "opendiscord:number-starts-with"|
+    "opendiscord:number-ends-with"|
+    "opendiscord:number-contains"|
+    "opendiscord:number-choices"|
+    "opendiscord:number-float"|
+    "opendiscord:number-negative"|
+    "opendiscord:number-positive"|
+    "opendiscord:number-zero"|

-    "openticket:boolean-true"|
-    "openticket:boolean-false"|
+    "opendiscord:boolean-true"|
+    "opendiscord:boolean-false"|

-    "openticket:array-empty-disabled"|
-    "openticket:array-empty-required"|
-    "openticket:array-too-short"|
-    "openticket:array-too-long"|
-    "openticket:array-length-invalid"|
-    "openticket:array-invalid-types"|
-    "openticket:array-double"|
+    "opendiscord:array-empty-disabled"|
+    "opendiscord:array-empty-required"|
+    "opendiscord:array-too-short"|
+    "opendiscord:array-too-long"|
+    "opendiscord:array-length-invalid"|
+    "opendiscord:array-invalid-types"|
+    "opendiscord:array-double"|

-    "openticket:discord-invalid-id"|
-    "openticket:discord-invalid-id-options"|
-    "openticket:discord-invalid-token"|
-    "openticket:color-invalid"|
-    "openticket:emoji-too-short"|
-    "openticket:emoji-too-long"|
-    "openticket:emoji-custom"|
-    "openticket:emoji-invalid"|
-    "openticket:url-invalid"|
-    "openticket:url-invalid-http"|
-    "openticket:url-invalid-protocol"|
-    "openticket:url-invalid-hostname"|
-    "openticket:url-invalid-extension"|
-    "openticket:url-invalid-path"|
-    "openticket:id-not-unique"|
-    "openticket:id-non-existent"|
+    "opendiscord:discord-invalid-id"|
+    "opendiscord:discord-invalid-id-options"|
+    "opendiscord:discord-invalid-token"|
+    "opendiscord:color-invalid"|
+    "opendiscord:emoji-too-short"|
+    "opendiscord:emoji-too-long"|
+    "opendiscord:emoji-custom"|
+    "opendiscord:emoji-invalid"|
+    "opendiscord:url-invalid"|
+    "opendiscord:url-invalid-http"|
+    "opendiscord:url-invalid-protocol"|
+    "opendiscord:url-invalid-hostname"|
+    "opendiscord:url-invalid-extension"|
+    "opendiscord:url-invalid-path"|
+    "opendiscord:id-not-unique"|
+    "opendiscord:id-non-existent"|

-    "openticket:invalid-language"|
-    "openticket:invalid-button"|
-    "openticket:unused-option"|
-    "openticket:unused-question"|
-    "openticket:dropdown-option"
+    "opendiscord:invalid-language"|
+    "opendiscord:invalid-button"|
+    "opendiscord:unused-option"|
+    "opendiscord:unused-question"|
+    "opendiscord:dropdown-option"
 )

 /**## ODCheckerTranslationRegister_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODCheckerTranslationRegister class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.checkers.translation`!
+ * This default class is made for the global variable `opendiscord.checkers.translation`!
 */
 export class ODCheckerTranslationRegister_Default extends ODCheckerTranslationRegister {
    get(type:"other", id:ODCheckerTranslationRegisterOtherIds_Default): string
@@ -346,16 +346,16 @@ export class ODCheckerTranslationRegister_Default extends ODCheckerTranslationRe
 * It's used to generate typescript declarations for this class.
 */
 export interface ODCheckerFunctionManagerIds_Default {
-    "openticket:unused-options":ODCheckerFunction,
-    "openticket:unused-questions":ODCheckerFunction,
-    "openticket:dropdown-options":ODCheckerFunction
+    "opendiscord:unused-options":ODCheckerFunction,
+    "opendiscord:unused-questions":ODCheckerFunction,
+    "opendiscord:dropdown-options":ODCheckerFunction
 }

 /**## ODCheckerFunctionManager_Default `default_class`
 * This is a special class that adds type definitions & typescript to the ODCheckerFunctionManager class.
 * It doesn't add any extra features!
 * 
- * This default class is made for the global variable `openticket.checkers.functions`!
+ * This default class is made for the global variable `opendiscord.checkers.functions`!
 */
 export class ODCheckerFunctionManager_Default extends ODCheckerFunctionManager {
    get<CheckerFunctionId extends keyof ODCheckerFunctionManagerIds_Default>(id:CheckerFunctionId): ODCheckerFunctionManagerIds_Default[CheckerFunctionId]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jasper	5d0776a9b9	Open Ticket v4.0.4 Open Ticket v4.0.4	2025-05-01 14:10:55 +02:00
Jasper	7bf843c851	Dev v4.0.4 Dev v4.0.4	2025-05-01 14:05:56 +02:00
DJj123dj	3e3ea9263f	Updated all versions to v4.0.4	2025-05-01 14:05:06 +02:00
DJj123dj	bb5c3e9c8d	Support for HTML Transcripts v2.1	2025-05-01 13:56:38 +02:00
Jasper	94f32674cb	Open Ticket v4.0.3 Open Ticket v4.0.3	2025-04-28 18:27:48 +02:00
DJj123dj	e8eb52e00b	#155 : Fixed reply on creation when disabled. Fixed a bug that caused the bot to send a partial ephemeral message while "replyOnTicketCreation" was disabled.	2025-04-28 18:22:54 +02:00
DJj123dj	4efa165949	Updated all versions to v4.0.3	2025-04-27 18:21:56 +02:00
DJj123dj	4c3e4ef9a5	Fixed bug due to discord.js new components	2025-04-27 18:17:38 +02:00
Jasper	6355fb5562	Open Ticket v4.0.2 Open Ticket v4.0.2	2025-04-12 19:19:06 +02:00
DJj123dj	442c201994	Updated all version badges to v4.0.2	2025-04-12 19:02:57 +02:00
DJj123dj	b61f9d4d5a	Update README.md	2025-04-12 18:57:53 +02:00
DJj123dj	129053b9f5	Fixed autoclose hours showing the wrong number. Fixed that the ticket message embed shows the wrong amount of hours when used manually with /autoclose enable	2025-04-08 22:06:22 +02:00
DJj123dj	35a0511b97	Merge branch 'dev' of https://github.com/open-discord-bots/open-ticket into dev	2025-04-08 22:01:38 +02:00
DJj123dj	bae221056c	Fixed #149 Tickets not changing categories	2025-04-08 22:01:36 +02:00
DJj123dj	9c6e4ccde4	Update checkerLoader.ts	2025-04-08 21:59:08 +02:00
Roppl3r	ac6845b4d4	Fixed Issue #151 (Max length for option 'name' should be 45, currently set to 50) Fixed config checker bug related to the name of a ticket option in a dropdown.	2025-04-08 21:58:03 +02:00
DJj123dj	75770c84b2	Update README.md preview images	2025-04-08 09:03:41 +02:00
DJj123dj	2281d78896	Implemented Vietnamese translations	2025-04-07 18:13:23 +02:00
ngocdiep2006	37cc3b794e	Added Vietnamese translation Create vietnamese.json	2025-04-07 18:07:59 +02:00
Jasper	9414b96221	Open Ticket v4.0.1 Open Ticket v4.0.1	2025-04-02 14:49:08 +02:00
Jasper	0befd2860e	Open Ticket v4.0.1 Open Ticket v4.0.1	2025-04-02 14:35:53 +02:00
DJj123dj	74d4ac24f2	Added new plugins to README.md	2025-04-02 07:34:42 +02:00
DJj123dj	364bf4f702	#144 : Added quick builders for plugins	2025-04-01 20:12:42 +02:00
DJj123dj	dd5b76f3d8	Update README.md	2025-03-31 21:36:07 +02:00
DJj123dj	a02ba56e9a	Updated README.md	2025-03-31 17:54:10 +02:00
DJj123dj	6d5bdc5dd4	#143 : Panels now edit after using dropdown From now on, all panels will update/edit themselfs after a dropdown has been used. This will reset the dropdown selection in the user client which results in a smoother user experience.	2025-03-29 13:16:27 +01:00
DJj123dj	51bfb1a367	#126 : ODManagers now use Maps instead of Arrays This results in a minor speed increase within large managers (e.g. builders, tickets, blacklist, ...)	2025-03-29 13:14:59 +01:00
DJj123dj	d85d842046	#142 : ODVersion + ODHTTPRequest improvements Added new methods to ODVersion class & added User-Agent header to ODHTTPRequest classes	2025-03-29 13:13:35 +01:00
DJj123dj	53136e0e6c	Fixed .DS_Store bug in plugin launcher	2025-03-29 13:10:58 +01:00
DJj123dj	2031a82523	#141 : Finished type simplifications	2025-03-29 13:10:27 +01:00
DJj123dj	453c48fab5	Update init.ts	2025-03-28 17:36:50 +01:00
DJj123dj	fd3bc0e7b9	API: allowCategoryChange param in related actions Added the 'allowCategoryChange' parameter in related ticket actions (claim, unclaim, close, reopen) to disable the changing of the category. This can be used by plugins not wanting the category of the channel to change.	2025-03-27 16:30:37 +01:00
DJj123dj	f316ae83e7	Update CONTENT_CREATORS.md	2025-03-26 15:29:31 +01:00
DJj123dj	d2c5cf0fc1	Added extra comments in some places	2025-03-26 15:24:56 +01:00
DJj123dj	45dfc18c1d	Updated all file versions to v4.0.1	2025-03-26 15:14:11 +01:00
DJj123dj	d81b1e7be3	The 4 new languages can now be used in OTv4.0.1	2025-03-26 15:13:55 +01:00
Jasper	2a82bdebae	Added 4 new languages (by NoOneNook) Added 4 new languages + updated README.md	2025-03-26 14:54:39 +01:00
NoOneNook	c9e13b2471	Update README.md	2025-03-25 23:58:45 +01:00
NoOneNook	cbeac2fda2	Update README.md	2025-03-25 23:50:12 +01:00
NoOneNook	8b1dd7d27a	Update README.md	2025-03-25 23:47:34 +01:00
NoOneNook	9e7cd28c6a	Russian language file I created a Russian language file using AI. This file has been verified in several other places and was also reviewed using ChatGPT afterwards to ensure that everything is correct, properly structured, and contains the necessary translations and messages for the system. ChatGPT was not used for translation, only to check that the entire file is correctly written in the Russian language	2025-03-25 23:46:52 +01:00
NoOneNook	fabe11bfd1	Update README.md	2025-03-25 23:22:26 +01:00
NoOneNook	79187b9995	Add files via upload	2025-03-25 23:21:29 +01:00
NoOneNook	a1251cf11c	Delete languages/latvian.json Wrong file! This language will be translated soon	2025-03-25 22:46:28 +01:00
NoOneNook	1bc8b2b401	Latvian (coming soon) tarted in a new language. Soon to be finished.	2025-03-25 22:43:51 +01:00
NoOneNook	ce727e52b0	Update on swedish.json Updated "translators": ["NoOneNook / ItsNook_"], to "translators": ["NoOneNook"],	2025-03-25 22:13:24 +01:00
NoOneNook	30233df7b0	Update on norwegian.json Updated "translators": ["NoOneNook"], to "translators": ["NoOneNook"],	2025-03-25 22:10:54 +01:00
NoOneNook	48d3296868	Delete languages/README.md Deleted README.md from wrong folder	2025-03-25 22:01:09 +01:00
NoOneNook	6b8ef26b4c	Remove README.md Deleted README.md text from wrong folder	2025-03-25 22:00:25 +01:00
NoOneNook	9c992c3dbd	name fix Updated readme below the lines for Norwegian and Swedish	2025-03-25 21:58:19 +01:00
NoOneNook	6feb56c25c	Name fix Fixed lines for Norwegian and Swedish	2025-03-25 21:56:40 +01:00
NoOneNook	e29b6afd87	Translate update Updated readme below the lines for Norwegian and Swedish	2025-03-25 21:54:18 +01:00
NoOneNook	d35b7fca99	Add files via upload Norwegian and Swedish translation complete	2025-03-25 21:49:40 +01:00
DJj123dj	126fada990	Merge branch 'dev'	2025-03-25 18:44:56 +01:00
DJj123dj	bd4929f11b	Updated all URLs for repository transfer	2025-03-25 17:49:42 +01:00
DJj123dj	d28fcf40d7	Fixed broken flag alias using --dev-database	2025-03-22 11:08:09 +01:00
DJj123dj	bed4e2a56a	Improved CONTRIBUTING.md & SECURITY.md markdown	2025-03-16 18:35:25 +01:00
DJj123dj	ba3a35a343	Added official Open Ticket Pterodactyl eggs!	2025-03-16 18:34:43 +01:00
DJj123dj	1e159c9bab	Improved dockerfile & compose	2025-03-12 22:13:00 +01:00
DJj123dj	e7ad3dd50b	Fixed startup crash codes (for Docker)	2025-03-12 22:12:51 +01:00
DJj123dj	177dee7468	Type simplifications (for documentation)	2025-02-27 20:51:59 +01:00
DJj123dj	0d40c23aa8	Fixed HTML Transcripts "member not found" error.	2025-02-19 15:48:37 +01:00
DJj123dj	15eef95fdd	Decreased /clear speed to reduce ratelimit chances	2025-02-19 15:43:43 +01:00
DJj123dj	c89e93d33d	Fixed crash resulting of non-returning statements	2025-02-19 15:29:16 +01:00
DJj123dj	e6c413cdf5	Fixed typos in comments	2025-02-18 18:18:10 +01:00
DJj123dj	b12556120c	Made database migration compatible with plugins	2025-02-17 19:44:18 +01:00
DJj123dj	58674452d8	Added quick setup to README.md	2025-02-15 19:01:53 +01:00
DJj123dj	a2f9593d55	Fixed #134 : text transcripts incorrect newlines	2025-02-15 18:22:23 +01:00
DJj123dj	9702c4d97d	Fixed stats resetting due to breaking change	2025-02-12 16:27:34 +01:00
DJj123dj	f13777e5f3	Update README.md	2025-02-09 11:34:37 +01:00
DJj123dj	9395e9af75	Added 13 new utility events for plugins	2025-02-09 11:19:03 +01:00
DJj123dj	b2a5e65fe2	Update README.md	2025-02-09 11:18:24 +01:00
DJj123dj	071c8f953c	Update createDocs.js	2025-02-05 17:04:10 +01:00
DJj123dj	9a4e5e2175	Merge branch 'dev' of https://github.com/DJj123dj/open-ticket into dev	2025-02-04 17:42:37 +01:00
DJj123dj	4e709f2a0b	Update createDocs.js	2025-02-04 17:42:24 +01:00
Jasper	27e3e78439	Fixed dateString() utility Fixed dateString() utility	2025-02-03 21:28:51 +01:00
DJj123dj	06e7919162	Fixed panel dropdown bug with empty option label	2025-02-03 21:01:36 +01:00
Roppl3r	bf952e3ef7	Fixed month parsing in dateString() utility causing incorrect dates in text transcripts.	2025-02-02 20:23:32 +01:00
DJj123dj	a397b66c9e	Update createDocs.js	2025-02-01 11:52:02 +01:00
DJj123dj	27f6e3a81f	Compiler will now only hash JS & TS files	2025-02-01 11:23:17 +01:00
DJj123dj	f2cefae37c	database will auto-update for the breaking change	2025-02-01 11:22:49 +01:00
DJj123dj	6acbf74846	BREAKING: changed all ids to "opendiscord:"	2025-02-01 10:29:35 +01:00
DJj123dj	29f8e1452c	BREAKING: changed openticket to opendiscord in API	2025-02-01 10:22:27 +01:00
DJj123dj	ce242741cd	Update README.md	2025-02-01 10:05:26 +01:00
DJj123dj	ac587568d3	Update createDocs.js	2025-01-31 17:14:56 +01:00
DJj123dj	f5e78949d7	Added typedoc for OT Docs API Reference	2025-01-31 16:03:02 +01:00
Jasper	f05d2d7d1b	Update README.md Updated v4.0 beta announcement	2025-01-07 18:54:24 +01:00
Jasper	0604e334ed	Open Ticket v3.5.9 Improved: - Updated discord.js to `v14.17.2` Fixed: - discord.js PermissionOverwrites => `Supplied parameter is not a User nor a Role` - message `"ephemeral"` is deprecated warning - A few config checker typos	2025-01-04 09:52:57 +01:00
DJj123dj	e9d20c0a14	Improvements + Updated discord.js to v14.17.2	2025-01-04 09:50:17 +01:00
DJj123dj	67465bfdf4	Bugfix: ephemeral in message reply is deprecated	2025-01-04 09:49:52 +01:00
DJj123dj	a66d3aad2d	Updated to v3.5.9	2025-01-04 09:36:42 +01:00
DJj123dj	f2de7fc408	Bugfix: discord.js PermissionOverwrites id invalid	2025-01-04 09:35:48 +01:00
Jasper	fc8a252e67	Translation Credits Gives some credit to AI that notmega used while doing his translations	2024-10-21 18:29:12 +02:00
Ronalds	ca9fe0aa77	add some credit to ai	2024-10-20 18:16:26 +03:00
Jasper	9028eaa16a	Update README.md	2024-08-21 14:24:55 +02:00
Jasper	e1f4936ae6	Open Ticket v3.5.8 fixed: - updated hungarian translation (by kornel0706) - updated turkish translation (by 0x15d3) - updated portuguese translation (by quiradon) - updated czech translation (by spyeye_) - fixed "unknown interaction" on ticket creation (in certain situations)	2024-08-02 14:51:17 +02:00